Patrones Creacionales

 

Los patrones creaciones abstraen el proceso de instanciación y hacen que el sistema sea independiente de la creación de los objetos.

Dentro de los patrones creacionales se tiene:

Abstract Factory

Permite la creación de familias de objetos relacionados que dependen entre si.

Motivación: La motivación para la creación de este patróo es a aceptación de multiples presentaciones de usuario, por ejemplo vamos a suponer que deseamos construir una aplicación en la que necesitemos tener diferentes look and feel entonces se lo puede solocionar por medio de este patron.

Estructura:

Participantes:

• Fabrica Abstracta: Declara una interfaz para operaciones que crean objetos de producto abstracto
• FabricaConcreta: Implementa las operaciones para crear objetos producto concreto
• ProductoAbstracto: Declara una interfaz para un tipo de objeto producto
• ProductoConcreto: Define un objeto producto para que sea creado por la fabrica correspondiente
• Cliente: Usa las interfaces de FabricaAbstracta y ProductoAbstracto

Implementación c#

using System;

namespace Patterns.Creational
{
    class AbstractFactoryPattern
    {
        public static void Main()
        {
            // Abstract factory #1
            AbstractFactory factory1 = new ConcreteFactory1();
            Client c1 = new Client(factory1);
            c1.Run();

            // Abstract factory #2
            AbstractFactory factory2 = new ConcreteFactory2();
            Client c2 = new Client(factory2);
            c2.Run();

            // Wait for user input
            Console.Read();
        }
    }

    // "AbstractFactory" 

    abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }

    // "ConcreteFactory1" 

    class ConcreteFactory1 : AbstractFactory
    {
        public ConcreteFactory1()
        {
            int a = 1;
        }
        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    // "ConcreteFactory2" 

    class ConcreteFactory2 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }

    // "AbstractProductA" 

    abstract class AbstractProductA
    {

    }

    // "AbstractProductB" 

    abstract class AbstractProductB
    {
        public abstract void Interact(AbstractProductA a);
    }

    // "ProductA1" 

    class ProductA1 : AbstractProductA
    {
    }

    // "ProductB1" 

    class ProductB1 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

    // "ProductA2" 

    class ProductA2 : AbstractProductA
    {
    }

    // "ProductB2" 

    class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

    // "Client" - the interaction environment of the products 

    class Client
    {
        private AbstractProductA AbstractProductA;
        private AbstractProductB AbstractProductB;

        // Constructor
        public Client(AbstractFactory factory)
        {
            AbstractProductB = factory.CreateProductB();
            AbstractProductA = factory.CreateProductA();
        }

        public void Run()
        {
            AbstractProductB.Interact(AbstractProductA);
        }
    }
}

Implementación de ejemplo c#

using System;

namespace Patterns.Creational
{
    // MainApp test application 

    class ExampleAbstractFactory
    {
        public static void Main()
        {
            // Create and run the Africa animal world
            ContinentFactory africa = new AfricaFactory();
            AnimalWorld world = new AnimalWorld(africa);
            world.RunFoodChain();

            // Create and run the America animal world
            ContinentFactory america = new AmericaFactory();
            world = new AnimalWorld(america);
            world.RunFoodChain();

            // Wait for user input
            Console.Read();
        }
    }

    // "AbstractFactory" 

    abstract class ContinentFactory
    {
        public abstract Herbivore CreateHerbivore();
        public abstract Carnivore CreateCarnivore();
    }

    // "ConcreteFactory1" 

    class AfricaFactory : ContinentFactory
    {
        public override Herbivore CreateHerbivore()
        {
            return new Wildebeest();
        }
        public override Carnivore CreateCarnivore()
        {
            return new Lion();
        }
    }

    // "ConcreteFactory2" 

    class AmericaFactory : ContinentFactory
    {
        public override Herbivore CreateHerbivore()
        {
            return new Bison();
        }
        public override Carnivore CreateCarnivore()
        {
            return new Wolf();
        }
    }

    // "AbstractProductA" 

    abstract class Herbivore
    {
    }

    // "AbstractProductB" 

    abstract class Carnivore
    {
        public abstract void Eat(Herbivore h);
    }

    // "ProductA1" 

    class Wildebeest : Herbivore
    {
    }

    // "ProductB1" 

    class Lion : Carnivore
    {
        public override void Eat(Herbivore h)
        {
            // Eat Wildebeest
            Console.WriteLine(this.GetType().Name +
              " eats " + h.GetType().Name);
        }
    }

    // "ProductA2" 

    class Bison : Herbivore
    {
    }

    // "ProductB2" 

    class Wolf : Carnivore
    {
        public override void Eat(Herbivore h)
        {
            // Eat Bison
            Console.WriteLine(this.GetType().Name +
              " eats " + h.GetType().Name);
        }
    }

    // "Client" 

    class AnimalWorld
    {
        private Herbivore herbivore;
        private Carnivore carnivore;

        // Constructor
        public AnimalWorld(ContinentFactory factory)
        {
            carnivore = factory.CreateCarnivore();
            herbivore = factory.CreateHerbivore();
        }

        public void RunFoodChain()
        {
            carnivore.Eat(herbivore);
        }
    }
}