抽象工厂模式（Abstract Factory Pattern）

      抽象工厂模式（Abstract Factory Pattern）是工厂方法模式（Factory Method Pattern）进化出的模式，在系统中用于完成“一系列相互依赖的对象”的创建工作，同时由于需求的变化，往往存在着更多系列对象的创建工作。

      下面实现该模式的代码，仍然以匹萨快餐店为例，在工厂方法模式的示例中，匹萨店有了许多分店，现在匹萨店的老板要考虑各分店的匹萨原料来源了。在示例中，匹萨的4个原料是“一系列相互依赖的对象”，假设需求的变化点是匹萨店的位置，每个匹萨分店都有一“系列”的原料，而匹萨原料个数（4个）基本不会改变。

      抽象工厂模式的结构图，在实现代码中的对应关系是：

      PizzaIngredientFactory = AbstractFactory

      NYPizzaIngredientFactory = ProductFactory1

      ChicagoIngredientFactory = ProductFactory2

      Dough = AbstractProductA

      ThickCrustDough = ProductA1

      ThinCrustDough = ProductA2

      Sauce = AbstractProductB

      ......

 

 

  1       class  App
  2      {
  3           static   void  Main()
  4          {
  5               // 在纽约的一家匹萨店，一位客人订购了一份干酪匹萨
  6                PizzaStore nyStore  =   new  NYPizzaStore();
  7 
  8              Pizza nyPizza  =  nyStore.CreatePizza(PizzaType.干酪匹萨);
  9          }
 10      }
 11 
 12       #region  匹萨快餐店
 13        public   abstract   class  PizzaStore
 14      {
 15           public   abstract  Pizza CreatePizza(PizzaType type);
 16      }
 17 
 18       ///   <summary>
 19       ///  纽约匹萨店
 20       ///   </summary>
 21       public   class  NYPizzaStore : PizzaStore
 22      {
 23           public   override  Pizza CreatePizza(PizzaType type)
 24          {
 25              Pizza pizza  =   null ;
 26              PizzaIngredientFactory pizzaIngredientFactory  =   new  NYPizzaIngredientFactory();
 27               switch  (type)
 28              {
 29                   case  PizzaType.干酪匹萨:
 30                      pizza  =   new  CheesePizza(pizzaIngredientFactory);
 31                      pizza.Name  =   " 纽约式干酪匹萨 " ;
 32                       break ;
 33                   case  PizzaType.蛤蜊匹萨:
 34                      pizza  =   new  ClamPizza(pizzaIngredientFactory);
 35                      pizza.Name  =   " 纽约式蛤蜊匹萨 " ;
 36                       break ;
 37                   default :
 38                       break ;
 39              }
 40 
 41               if  (pizza  !=   null ) pizza.Produce();
 42 
 43               return  pizza;
 44          }
 45      }
 46 
 47       ///   <summary>
 48       ///  芝加哥匹萨店
 49       ///   </summary>
 50       public   class  ChicagoPizzaStore : PizzaStore
 51      {
 52           public   override  Pizza CreatePizza(PizzaType type)
 53          {
 54              Pizza pizza  =   null ;
 55              PizzaIngredientFactory pizzaIngredientFactory  =   new  ChicagoIngredientFactory();
 56               switch  (type)
 57              {
 58                   case  PizzaType.干酪匹萨:
 59                      pizza  =   new  CheesePizza(pizzaIngredientFactory);
 60                      pizza.Name  =   " 芝加哥式干酪匹萨 " ;
 61                       break ;
 62                   case  PizzaType.蛤蜊匹萨:
 63                      pizza  =   new  ClamPizza(pizzaIngredientFactory);
 64                      pizza.Name  =   " 芝加哥式蛤蜊匹萨 " ;
 65                       break ;
 66                   default :
 67                       break ;
 68              }
 69 
 70               if  (pizza  !=   null ) pizza.Produce();
 71 
 72               return  pizza;
 73          }
 74      }
 75       #endregion
 76 
 77       #region  匹萨
 78        public   enum  PizzaType
 79      {
 80          干酪匹萨  =   1 ,
 81          蛤蜊匹萨  =   2
 82      }
 83 
 84       public   abstract   class  Pizza
 85      {
 86           protected  Dough dough;
 87           protected  Sauce sauce;
 88           protected  Cheese cheese;
 89           protected  Clams clam;
 90 
 91           protected   abstract   void  Prepare();
 92 
 93           protected   virtual   void  Bake()
 94          {
 95              Console.WriteLine( " 350度烘烤25分钟 " );
 96          }
 97 
 98           protected   virtual   void  Cut()
 99          {
              Console.WriteLine( " 将匹萨切成尖角型 " );
          }
 
           protected   virtual   void  Box()
          {
              Console.WriteLine( " 将匹萨打包成商务餐装 " );
          }
 
           public   virtual   void  Produce()
          {
              Prepare();
              Bake();
              Cut();
              Box();
          }
 
           public   string  Name {  get ;  set ; }
      }
 
       public   class  CheesePizza : Pizza
      {
          PizzaIngredientFactory factory  =   null ;
           public  CheesePizza(PizzaIngredientFactory factory)
          {
               this .factory  =  factory;
          }
 
           protected   override   void  Prepare()
          {
               this .dough  =  factory.CreateDough();
               this .sauce  =  factory.CreateSauce();
               this .cheese  =  factory.CreateCheese();
 
              Console.WriteLine( " 准备做一个 {0} " , Name);
              Console.WriteLine( " 制作匹萨面皮 " );
              Console.WriteLine( " 添加调味汁 " );
              Console.WriteLine( " 添加表面材料 " );
          }
      }
 
       public   class  ClamPizza : Pizza
      {
          PizzaIngredientFactory factory  =   null ;
           public  ClamPizza(PizzaIngredientFactory factory)
          {
               this .factory  =  factory;
          }
 
           protected   override   void  Prepare()
          {
               this .dough  =  factory.CreateDough();
               this .sauce  =  factory.CreateSauce();
               this .clam  =  factory.CreateClams();
 
              Console.WriteLine( " 准备做一个 {0} " , Name);
              Console.WriteLine( " 制作匹萨面皮 " );
              Console.WriteLine( " 添加调味汁 " );
              Console.WriteLine( " 添加表面材料 " );
          }
      }
       #endregion
 
       #region  匹萨原料工厂
 
       public   interface  PizzaIngredientFactory
      {
          Dough CreateDough();
          Sauce CreateSauce();
          Cheese CreateCheese();
          Clams CreateClams();
      }
 
       public   class  NYPizzaIngredientFactory : PizzaIngredientFactory
      {
           public  Dough CreateDough()
          {
               // 纽约人做匹萨都用薄皮面团
               return   new  ThinCrustDough();
          }
 
           public  Sauce CreateSauce()
          {
               // 纽约人喜欢意式沙司
               return   new  MarinaraSauce();
          }
 
           public  Cheese CreateCheese()
          {
               // 纽约人喜欢乳酪奶酪
               return   new  ReggianoCheese();
          }
 
           public  Clams CreateClams()
          {
               // 纽约人喜欢生鲜蛤蜊
               return   new  FreshClams();
          }
      }
 
       public   class  ChicagoIngredientFactory : PizzaIngredientFactory
      {
           public  Dough CreateDough()
          {
               // 芝加哥人做匹萨都用厚皮面团
               return   new  ThickCrustDough();
          }
 
           public  Sauce CreateSauce()
          {
               // 芝加哥人喜欢番茄沙司
               return   new  PlumTomatoSauce();
          }
 
           public  Cheese CreateCheese()
          {
               // 芝加哥人喜欢意式奶酪
               return   new  MozzarellaCheese();
          }
 
           public  Clams CreateClams()
          {
               // 芝加哥人喜欢冰冻蛤蜊
               return   new  FrozenClams();
          }
      }
       #endregion
 
       #region  匹萨使用的原料
 
       public   interface  Dough
      {
           string  PizzaDough();
      }
 
       public   class  ThickCrustDough : Dough
      {
           public   string  PizzaDough()
          {
               return   " 厚皮面团 " ;
          }
      }
 
       public   class  ThinCrustDough : Dough
      {
           public   string  PizzaDough()
          {
               return   " 薄皮面团 " ;
          }
      }
      
       public   interface  Sauce
      {
           string  PizzaSauce();
      }
 
       public   class  PlumTomatoSauce : Sauce
      {
           public   string  PizzaSauce()
          {
               return   " 番茄沙司 " ;
          }
      }
 
       public   class  MarinaraSauce : Sauce
      {
           public   string  PizzaSauce()
          {
               return   " 意式沙司 " ;
          }
      }
      
       public   interface  Cheese
      {
           string  PizzaTopCheese();
      }
 
       public   class  MozzarellaCheese : Cheese
      {
           public   string  PizzaTopCheese()
          {
               return   " 意式奶酪 " ;
          }
      }
 
       public   class  ReggianoCheese : Cheese
      {
           public   string  PizzaTopCheese()
          {
               return   " 乳酪奶酪 " ;
          }
      }
 
       public   interface  Clams
      {
           string  PizzaTopClams();
      }
 
       public   class  FrozenClams : Clams
      {
           public   string  PizzaTopClams()
          {
               return   " 冰冻蛤蜊 " ;
          }
      }
 
       public   class  FreshClams : Clams
      {
           public   string  PizzaTopClams()
          {
               return   " 生鲜蛤蜊 " ;
          }
      }
       #endregion