Design Pattern:Abstract Factory

一定义：抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。

二UML类图：

三模式角色与结构：

AbstractFactory：声明创建抽象产品的接口

ConcreteFactory：实现抽象工厂，创建具体产品

AbstractProduct：声明产品的接口

Product：实现抽象产品接口，也是具体工厂的产品

Client：使用抽象工厂和抽象产品创建具体的类

四程序举例

using System;
  
 namespace DoFactory.GangOfFour.Abstract.Structural
 {
   /// <summary>
   /// MainApp startup class for Structural
   /// Abstract Factory Design Pattern.
   /// </summary>
   class MainApp
   {
     /// <summary>
     /// Entry point into console application.
     /// </summary>
     public static void Main()
     {
       // Abstract factory #1
       AbstractFactory factory1 = new ConcreteFactory1();
       Client client1 = new Client(factory1);
       client1.Run();
  
       // Abstract factory #2
       AbstractFactory factory2 = new ConcreteFactory2();
       Client client2 = new Client(factory2);
       client2.Run();
  
       // Wait for user input
       Console.ReadKey();
     }
   }
  
   /// <summary>
   /// The 'AbstractFactory' abstract class
   /// </summary>
   abstract class AbstractFactory
   {
     public abstract AbstractProductA CreateProductA();
     public abstract AbstractProductB CreateProductB();
   }
  
  
   /// <summary>
   /// The 'ConcreteFactory1' class
   /// </summary>
   class ConcreteFactory1 : AbstractFactory
   {
     public override AbstractProductA CreateProductA()
     {
       return new ProductA1();
     }
     public override AbstractProductB CreateProductB()
     {
       return new ProductB1();
     }
   }
  
   /// <summary>
   /// The 'ConcreteFactory2' class
   /// </summary>
   class ConcreteFactory2 : AbstractFactory
   {
     public override AbstractProductA CreateProductA()
     {
       return new ProductA2();
     }
     public override AbstractProductB CreateProductB()
     {
       return new ProductB2();
     }
   }
  
   /// <summary>
   /// The 'AbstractProductA' abstract class
   /// </summary>
   abstract class AbstractProductA
   {
   }
  
   /// <summary>
   /// The 'AbstractProductB' abstract class
   /// </summary>
   abstract class AbstractProductB
   {
     public abstract void Interact(AbstractProductA a);
   }
  
  
   /// <summary>
   /// The 'ProductA1' class
   /// </summary>
   class ProductA1 : AbstractProductA
   {
   }
  
   /// <summary>
   /// The 'ProductB1' class
   /// </summary>
   class ProductB1 : AbstractProductB
   {
     public override void Interact(AbstractProductA a)
     {
       Console.WriteLine(this.GetType().Name +
         " interacts with " + a.GetType().Name);
     }
   }
  
   /// <summary>
   /// The 'ProductA2' class
   /// </summary>
   class ProductA2 : AbstractProductA
   {
   }
  
   /// <summary>
   /// The 'ProductB2' class
   /// </summary>
   class ProductB2 : AbstractProductB
   {
     public override void Interact(AbstractProductA a)
     {
       Console.WriteLine(this.GetType().Name +
         " interacts with " + a.GetType().Name);
     }
   }
  
   /// <summary>
   /// The 'Client' class. Interaction environment for the products.
   /// </summary>
   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);
     }
   }
 }
  

五显示效果：