建造者模式(Builder Pattern)

      建造者模式(Builder Pattern)是一种创建型模式(Creational Pattern)。主要用于一个“复杂对象”的创建工作,通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法确相对稳定。

      建造者模式同抽象工厂模式有一定的相似之处,抽象工厂模式主要解决的是需求的变化引起的“一系列对象”的创建工作,而建造者模式通常解决的是一个对象内部组成部分的变化。

      实现的代码仍然是匹萨店的例子,同抽象工厂中的例子大部分相同,不同的地方主要在匹萨原料的部分。匹萨的原料是建造者模式中要创建的对象,假设场景是:原料的种类是变化的部分,原料用量的算法是相对稳定的。

      下面是建造者模式的结构图,在实现代码中的对应关系是:

      PizzaIngredientBuilder = Builder

      NYPizzaIngredientBuilder(ChicagoIngredientBuilder) = ConcreteBuilder

      PizzaIngredient= Product

      IngredientManager = Director

      

      

 

  1     class App
  2     {
  3         static void Main()
  4         {
  5             //在纽约的一家匹萨店,一位客人订购了一份干酪匹萨
  6             PizzaStore nyStore = new NYPizzaStore();
  7 
  8             Pizza nyPizza = nyStore.CreatePizza(PizzaType.干酪匹萨);
  9 
 10             Console.ReadLine();
 11         }
 12     }
 13     
 14     #region 匹萨快餐店
 15     public abstract class PizzaStore
 16     {
 17         public abstract Pizza CreatePizza(PizzaType type);
 18     }
 19 
 20     /// <summary>
 21     /// 纽约匹萨店
 22     /// </summary>
 23     public class NYPizzaStore : PizzaStore
 24     {
 25         public override Pizza CreatePizza(PizzaType type)
 26         {
 27             Pizza pizza = null;
 28             PizzaIngredientBuilder nyBuilder = new NYPizzaIngredientBuilder();
 29             switch (type)
 30             {
 31                 case PizzaType.干酪匹萨:
 32                     pizza = new CheesePizza(nyBuilder);
 33                     pizza.Name = "纽约式干酪匹萨";
 34                     break;
 35                 case PizzaType.蛤蜊匹萨:
 36                     pizza = new ClamPizza(nyBuilder);
 37                     pizza.Name = "纽约式蛤蜊匹萨";
 38                     break;
 39                 default:
 40                     break;
 41             }
 42 
 43             if (pizza != null) pizza.Produce();
 44 
 45             return pizza;
 46         }
 47     }
 48 
 49     /// <summary>
 50     /// 芝加哥匹萨店
 51     /// </summary>
 52     public class ChicagoPizzaStore : PizzaStore
 53     {
 54         public override Pizza CreatePizza(PizzaType type)
 55         {
 56             Pizza pizza = null;
 57             PizzaIngredientBuilder chicagoBuilder = new ChicagoIngredientBuilder();
 58             switch (type)
 59             {
 60                 case PizzaType.干酪匹萨:
 61                     pizza = new CheesePizza(chicagoBuilder);
 62                     pizza.Name = "芝加哥式干酪匹萨";
 63                     break;
 64                 case PizzaType.蛤蜊匹萨:
 65                     pizza = new ClamPizza(chicagoBuilder);
 66                     pizza.Name = "芝加哥式蛤蜊匹萨";
 67                     break;
 68                 default:
 69                     break;
 70             }
 71 
 72             if (pizza != null) pizza.Produce();
 73 
 74             return pizza;
 75         }
 76     }
 77     #endregion
 78 
 79     #region 匹萨
 80     public enum PizzaType
 81     {
 82         干酪匹萨 = 1,
 83         蛤蜊匹萨 = 2
 84     }
 85 
 86     public abstract class Pizza
 87     {
 88         protected PizzaIngredient ingredient;
 89 
 90         protected abstract void Prepare();
 91 
 92         protected virtual void Bake()
 93         {
 94             Console.WriteLine("350度烘烤25分钟");
 95         }
 96 
 97         protected virtual void Cut()
 98         {
 99             Console.WriteLine("将匹萨切成尖角型");
100         }
101 
102         protected virtual void Box()
103         {
104             Console.WriteLine("将匹萨打包成商务餐装");
105         }
106 
107         public virtual void Produce()
108         {
109             Prepare();
110             Bake();
111             Cut();
112             Box();
113         }
114 
115         public string Name { getset; }
116     }
117 
118     public class CheesePizza : Pizza
119     {
120         PizzaIngredientBuilder builder = null;
121         public CheesePizza(PizzaIngredientBuilder builder)
122         {
123             this.builder = builder;
124         }
125 
126         protected override void Prepare()
127         {
128             this.ingredient = IngredientManager.Construct(builder);
129 
130             Console.WriteLine("准备做一个 {0}", Name);
131             Console.WriteLine("     准备{0}{1}份", ingredient.DoughIngredient[0].PizzaDough(), ingredient.DoughIngredient.Count);
132             Console.WriteLine("     准备{0}{1}份", ingredient.SauceIngredient[0].PizzaSauce(), ingredient.SauceIngredient.Count);
133             Console.WriteLine("     准备{0}{1}份", ingredient.CheeseIngredient[0].PizzaTopCheese(), ingredient.CheeseIngredient.Count);
134             Console.WriteLine("     准备{0}{1}份", ingredient.ClamsIngredient[0].PizzaTopClams(), ingredient.ClamsIngredient.Count);
135         }
136     }
137 
138     public class ClamPizza : Pizza
139     {
140         PizzaIngredientBuilder builder = null;
141         public ClamPizza(PizzaIngredientBuilder builder)
142         {
143             this.builder = builder;
144         }
145 
146         protected override void Prepare()
147         {
148             this.ingredient = IngredientManager.Construct(builder);
149 
150             Console.WriteLine("准备做一个 {0}", Name);
151             Console.WriteLine("     准备{0}{1}份", ingredient.DoughIngredient[0].PizzaDough(), ingredient.DoughIngredient.Count);
152             Console.WriteLine("     准备{0}{1}份", ingredient.SauceIngredient[0].PizzaSauce(), ingredient.SauceIngredient.Count);
153             Console.WriteLine("     准备{0}{1}份", ingredient.CheeseIngredient[0].PizzaTopCheese(), ingredient.CheeseIngredient.Count);
154             Console.WriteLine("     准备{0}{1}份", ingredient.ClamsIngredient[0].PizzaTopClams(), ingredient.ClamsIngredient.Count);
155         }
156     }
157     #endregion
158 
159     #region 匹萨原料
160 
161     public class IngredientManager
162     {
163         public static PizzaIngredient Construct(PizzaIngredientBuilder builder)
164         {
165             builder.CreateDough();
166             builder.CreateDough();
167             builder.CreateDough();
168 
169             builder.CreateSauce();
170             builder.CreateSauce();
171 
172             builder.CreateCheese();
173             builder.CreateClams();
174 
175             return builder.GetPizzaIngredient();
176         }
177     }
178 
179     public class PizzaIngredient
180     {
181         private List<Dough> dough = new List<Dough>();
182         public List<Dough> DoughIngredient 
183         {
184             get { return dough; }
185             set { dough = value; }
186         }
187 
188         private List<Sauce> sauce = new List<Sauce>();
189         public List<Sauce> SauceIngredient
190         {
191             get { return sauce; }
192             set { sauce = value; }
193         }
194 
195         private List<Cheese> cheese = new List<Cheese>();
196         public List<Cheese> CheeseIngredient 
197         {
198             get { return cheese; }
199             set { cheese = value; }
200         }
201 
202         private List<Clams> clams = new List<Clams>();
203         public List<Clams> ClamsIngredient
204         {
205             get { return clams; }
206             set { clams = value; }
207         }
208     }
209 
210     public interface PizzaIngredientBuilder
211     {
212         void CreateDough();
213         void CreateSauce();
214         void CreateCheese();
215         void CreateClams();
216 
217         PizzaIngredient GetPizzaIngredient();
218     }
219 
220     public class NYPizzaIngredientBuilder : PizzaIngredientBuilder
221     {
222         PizzaIngredient ingredient = new PizzaIngredient();
223 
224         public NYPizzaIngredientBuilder()
225         {
226             ingredient = new PizzaIngredient();
227         }
228 
229         public void CreateDough()
230         {
231             //纽约人做匹萨都用薄皮面团
232             ingredient.DoughIngredient.Add(new ThinCrustDough());
233         }
234 
235         public void CreateSauce()
236         {
237             //纽约人喜欢意式沙司
238             ingredient.SauceIngredient.Add(new MarinaraSauce());
239         }
240 
241         public void CreateCheese()
242         {
243             //纽约人喜欢乳酪奶酪
244             ingredient.CheeseIngredient.Add(new ReggianoCheese());
245         }
246 
247         public void CreateClams()
248         {
249             //纽约人喜欢生鲜蛤蜊
250             ingredient.ClamsIngredient.Add(new FreshClams());
251         }
252 
253         public PizzaIngredient GetPizzaIngredient()
254         {
255             return ingredient;
256         }
257     }
258 
259     public class ChicagoIngredientBuilder : PizzaIngredientBuilder
260     {
261         PizzaIngredient ingredient = null;
262 
263         public ChicagoIngredientBuilder()
264         {
265             ingredient = new PizzaIngredient();
266         }
267 
268         public void CreateDough()
269         {
270             //芝加哥人做匹萨都用厚皮面团
271             ingredient.DoughIngredient.Add(new ThickCrustDough());
272         }
273 
274         public void CreateSauce()
275         {
276             //芝加哥人喜欢番茄沙司
277             ingredient.SauceIngredient.Add(new PlumTomatoSauce());
278         }
279 
280         public void CreateCheese()
281         {
282             //芝加哥人喜欢意式奶酪
283             ingredient.CheeseIngredient.Add(new MozzarellaCheese());
284         }
285 
286         public void CreateClams()
287         {
288             //芝加哥人喜欢冰冻蛤蜊
289             ingredient.ClamsIngredient.Add(new FrozenClams());
290         }
291 
292         public PizzaIngredient GetPizzaIngredient()
293         {
294             return ingredient;
295         }
296     }
297     #endregion
298 
299     #region 匹萨使用的原料
300 
301     public interface Dough
302     {
303         string PizzaDough();
304     }
305 
306     public class ThickCrustDough : Dough
307     {
308         public string PizzaDough()
309         {
310             return "厚皮面团";
311         }
312     }
313 
314     public class ThinCrustDough : Dough
315     {
316         public string PizzaDough()
317         {
318             return "薄皮面团";
319         }
320     }
321 
322     public interface Sauce
323     {
324         string PizzaSauce();
325     }
326 
327     public class PlumTomatoSauce : Sauce
328     {
329         public string PizzaSauce()
330         {
331             return "番茄沙司";
332         }
333     }
334 
335     public class MarinaraSauce : Sauce
336     {
337         public string PizzaSauce()
338         {
339             return "意式沙司";
340         }
341     }
342 
343     public interface Cheese
344     {
345         string PizzaTopCheese();
346     }
347 
348     public class MozzarellaCheese : Cheese
349     {
350         public string PizzaTopCheese()
351         {
352             return "意式奶酪";
353         }
354     }
355 
356     public class ReggianoCheese : Cheese
357     {
358         public string PizzaTopCheese()
359         {
360             return "乳酪奶酪";
361         }
362     }
363 
364     public interface Clams
365     {
366         string PizzaTopClams();
367     }
368 
369     public class FrozenClams : Clams
370     {
371         public string PizzaTopClams()
372         {
373             return "冰冻蛤蜊";
374         }
375     }
376 
377     public class FreshClams : Clams
378     {
379         public string PizzaTopClams()
380         {
381             return "生鲜蛤蜊";
382         }
383     }
384     #endregion

 

posted @ 2009-07-14 23:55  binfen  阅读(499)  评论(0编辑  收藏  举报