Abstract Factory (Fabrica Abstracta) Patron de diseño

Crea una instancia de varias familias de clases

Definición


Proporcionar una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.

Frecuencia de uso:

High

UML class diagram

Los participantes


Las clases y los objetos que participan en este modelo son:

• AbstractFactory (ContinentFactory) 

1. declara una interfaz para las operaciones que crean productos abstractos 

• ConcreteFactory (AfricaFactory, AmericaFactory) 

1. implementa las operaciones para crear objetos de productos concretos 

• AbstractProduct (Herbivore, Carnivore) 

1. declara una interfaz para un tipo del objeto Product

• Product (Wildebeest, Lion, Bison, Wolf) 

1. define un objeto de producto que se crea por la correspondiente fábrica de hormigón 
2. implementa la interfaz AbstractProduct 

• Client (AnimalWorld) 

1. utiliza interfaces declaradas por las clases AbstractFactory y AbstractProduct 

Código estructural en C # 

Este código estructural demuestra el patrón Abstract Factory crear jerarquías paralelas de los objetos. Creación de objetos ha sido abstraído y no hay necesidad de nombres de clase no modificables en el código de cliente.

1. using System;
2. 
   
3. namespace Abstract.Structural
4. {
5.   /// <summary>
6.   /// MainApp startup class for Structural
7.   /// Abstract Factory Design Pattern.
8.   /// </summary>
9.   class MainApp
10.   {
11.     /// <summary>
12.     /// Entry point into console application.
13.     /// </summary>
14.     public static void Main()
15.     {
16.       // Abstract factory #1
17.       AbstractFactory factory1 = new ConcreteFactory1();
18.       Client client1 = new Client(factory1);
19.       client1.Run();
20. 
    
21.       // Abstract factory #2
22.       AbstractFactory factory2 = new ConcreteFactory2();
23.       Client client2 = new Client(factory2);
24.       client2.Run();
25. 
    
26.       // Wait for user input
27.       Console.ReadKey();
28.     }
29.   }
30. 
    
31.   /// <summary>
32.   /// The 'AbstractFactory' abstract class
33.   /// </summary>
34.   abstract class AbstractFactory
35.   {
36.     public abstract AbstractProductA CreateProductA();
37.     public abstract AbstractProductB CreateProductB();
38.   }
39. 
    
40. 
    
41.   /// <summary>
42.   /// The 'ConcreteFactory1' class
43.   /// </summary>
44.   class ConcreteFactory1 : AbstractFactory
45.   {
46.     public override AbstractProductA CreateProductA()
47.     {
48.       return new ProductA1();
49.     }
50.     public override AbstractProductB CreateProductB()
51.     {
52.       return new ProductB1();
53.     }
54.   }
55. 
    
56.   /// <summary>
57.   /// The 'ConcreteFactory2' class
58.   /// </summary>
59.   class ConcreteFactory2 : AbstractFactory
60.   {
61.     public override AbstractProductA CreateProductA()
62.     {
63.       return new ProductA2();
64.     }
65.     public override AbstractProductB CreateProductB()
66.     {
67.       return new ProductB2();
68.     }
69.   }
70. 
    
71.   /// <summary>
72.   /// The 'AbstractProductA' abstract class
73.   /// </summary>
74.   abstract class AbstractProductA
75.   {
76.   }
77. 
    
78.   /// <summary>
79.   /// The 'AbstractProductB' abstract class
80.   /// </summary>
81.   abstract class AbstractProductB
82.   {
83.     public abstract void Interact(AbstractProductA a);
84.   }
85. 
    
86. 
    
87.   /// <summary>
88.   /// The 'ProductA1' class
89.   /// </summary>
90.   class ProductA1 : AbstractProductA
91.   {
92.   }
93. 
    
94.   /// <summary>
95.   /// The 'ProductB1' class
96.   /// </summary>
97.   class ProductB1 : AbstractProductB
98.   {
99.     public override void Interact(AbstractProductA a)
100.     {
101.       Console.WriteLine(this.GetType().Name +
102.         " interacts with " + a.GetType().Name);
103.     }
104.   }
105. 
     
106.   /// <summary>
107.   /// The 'ProductA2' class
108.   /// </summary>
109.   class ProductA2 : AbstractProductA
110.   {
111.   }
112. 
     
113.   /// <summary>
114.   /// The 'ProductB2' class
115.   /// </summary>
116.   class ProductB2 : AbstractProductB
117.   {
118.     public override void Interact(AbstractProductA a)
119.     {
120.       Console.WriteLine(this.GetType().Name +
121.         " interacts with " + a.GetType().Name);
122.     }
123.   }
124. 
     
125.   /// <summary>
126.   /// The 'Client' class. Interaction environment for the products.
127.   /// </summary>
128.   class Client
129.   {
130.     private AbstractProductA _abstractProductA;
131.     private AbstractProductB _abstractProductB;
132. 
     
133.     // Constructor
134.     public Client(AbstractFactory factory)
135.     {
136.       _abstractProductB = factory.CreateProductB();
137.       _abstractProductA = factory.CreateProductA();
138.     }
139. 
     
140.     public void Run()
141.     {
142.       _abstractProductB.Interact(_abstractProductA);
143.     }
144.   }
145. }

Resultado

ProductB1 interacts with ProductA1
ProductB2 interacts with ProductA2

Código del mundo real en C #

Este código del mundo real demuestra la creación de diferentes animales para un juego de ordenador utilizando diferentes fábricas. Aunque los animales creados por las fábricas son de continente diferentes, las interacciones entre los animales siguen siendo los mismos.

1. using System;
2. 
   
3. namespace Abstract.RealWorld
4. {
5.   /// <summary>
6.   /// MainApp startup class for Real-World
7.   /// Abstract Factory Design Pattern.
8.   /// </summary>
9.   class MainApp
10.   {
11.     /// <summary>
12.     /// Entry point into console application.
13.     /// </summary>
14.     public static void Main()
15.     {
16.       // Create and run the African animal world
17.       ContinentFactory africa = new AfricaFactory();
18.       AnimalWorld world = new AnimalWorld(africa);
19.       world.RunFoodChain();
20. 
    
21.       // Create and run the American animal world
22.       ContinentFactory america = new AmericaFactory();
23.       world = new AnimalWorld(america);
24.       world.RunFoodChain();
25.       // Wait for user input
26.       Console.ReadKey();
27.     }
28.   }
29. 
    
30.   /// <summary>
31.   /// The 'AbstractFactory' abstract class
32.   /// </summary>
33.   abstract class ContinentFactory
34.   {
35.     public abstract Herbivore CreateHerbivore();
36.     public abstract Carnivore CreateCarnivore();
37.   }
38. 
    
39.   /// <summary>
40.   /// The 'ConcreteFactory1' class
41.   /// </summary>
42.   class AfricaFactory : ContinentFactory
43.   {
44.     public override Herbivore CreateHerbivore()
45.     {
46.      return new Wildebeest();
47.     }
48.     public override Carnivore CreateCarnivore()
49.     {
50.       return new Lion();
51.     }
52.   }
53. 
    
54.   /// <summary>
55.   /// The 'ConcreteFactory2' class
56.   /// </summary>
57.   class AmericaFactory : ContinentFactory
58.   {
59.     public override Herbivore CreateHerbivore()
60.     {
61.       return new Bison();
62.     }
63.     public override Carnivore CreateCarnivore()
64.     {
65.       return new Wolf();
66.     }
67.   }
68. 
    
69.   /// <summary>
70.   /// The 'AbstractProductA' abstract class
71.   /// </summary>
72.   abstract class Herbivore
73.   {
74.   }
76.   /// <summary>
77.   /// The 'AbstractProductB' abstract class
78.   /// </summary>
79.   abstract class Carnivore
80.   {
81.     public abstract void Eat(Herbivore h);
82.   }
83.   /// <summary>
84.   /// The 'ProductA1' class
85.   /// </summary>
86.   class Wildebeest : Herbivore
87.   {
88.   }
89. 
    
90.   /// <summary>
91.   /// The 'ProductB1' class
92.   /// </summary>
93.   class Lion : Carnivore
94.   {
95.     public override void Eat(Herbivore h)
96.     {
97.       // Eat Wildebeest
98.      Console.WriteLine(this.GetType().Name +
99.         " eats " + h.GetType().Name);
100.     }
101.   }
102. 
     
103.   /// <summary>
104.   /// The 'ProductA2' class
105.   /// </summary>
106.   class Bison : Herbivore
107.   {
108.   }
109. 
     
110.   /// <summary>
111.   /// The 'ProductB2' class
112.   /// </summary>
113.   class Wolf : Carnivore
114.   {
115.     public override void Eat(Herbivore h)
116.     {
117.       // Eat Bison
118.       Console.WriteLine(this.GetType().Name +
119.         " eats " + h.GetType().Name);
120.     }
121.   }
122.   /// <summary>
123.   /// The 'Client' class
124.   /// </summary>
125.   class AnimalWorld
126.   {
127.     private Herbivore _herbivore;
128.     private Carnivore _carnivore;
129. 
     
130.     // Constructor
131.     public AnimalWorld(ContinentFactory factory)
132.     {
133.       _carnivore = factory.CreateCarnivore();
134.       _herbivore = factory.CreateHerbivore();
135.     }
136.     public void RunFoodChain()
137.     {
138.       _carnivore.Eat(_herbivore);
139.     }
140.   }
141. }

Resultado

Lion eats Wildebeest
Wolf eats Bison