设计模式（四）（Builder）创建者模式

定义：

　　建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。

适用性：

当流程算法可以固定几个步骤，步骤的算法步骤执行顺序固定，且制造的产品可以唯一确定，这时使用创建者模式。

模式思想：

对算法步骤进行封装(Director)，对流程算法步骤有统一的接口Builder，算法具体的每个步骤变化时，可以通过实现算法步骤借口类进行扩展或适配(ConcreteBuilder1,ConcreteBuilder2…)，Director不关心流程步骤，只负责流程算法执行顺序,从而达到了解耦，依赖倒置的思想。

模式结构图：

示例：

　　Builder:

 1     /// <summary>
 2     /// Description of ValidateCodeBuilderBase.
 3     /// </summary>
 4     public abstract class ValidateCodeBuilderBase
 5     {
 6         protected ValidateCodeInfo ValidateCodeInfo=new ValidateCodeInfo();
 7         
 8         //生成随机数
 9         public abstract void CreateRandom();
10         
11         //绘制验证码图片
12         public abstract void CreateImageBmp();
13         
14         //混淆验证码图片
15         public abstract void DisposeImageBmp();    
16         
17         // 存放到session中
18         public abstract void SetSession();
19         
20         /// <summary>
21         /// 返回生成的验证码信息
22         /// </summary>
23         public abstract ValidateCodeInfo GetResult();
24     }

　　Director:

 1 public class ValidateCodeDirector
 2 {
 3         private ValidateCodeBuilderBase builder=null;
 4         
 5         public ValidateCodeDirector(ValidateCodeBuilderBase builder)
 6         {
 7             this.builder=builder;
 8         }
 9         
10         public ValidateCodeInfo MakeValidateCode()
11         {
12             this.builder.CreateRandom();
13             this.builder.CreateImageBmp();
14             this.builder.DisposeImageBmp();
15             this.builder.SetSession();
16             
17             return this.builder.GetResult();
18         }
19 }

　　Product:

1 public class ValidateCodeInfo
2     {
3         public Bitmap Bitmap{get;set;}
4         
5         public string ValidateCode{get;set;}
6     }

　　ConcreteBuilder1:

 1 public class ValidateCode_Style01:ValidateCodeBuilderBase
 2 {
 3         public override void CreateRandom()
 4         {
 5             //
 6         }
 7         
 8         public override void CreateImageBmp()
 9         {
10             //
11         }
12         
13         public override void DisposeImageBmp()
14         {
15             //
16         }
17         
18         public override void SetSession()
19         {
20             //
21         }
22         
23         public override ValidateCodeInfo GetResult()
24         {
25             return base.ValidateCodeInfo;
26         }
27     }

View Code

　　ConcreteBuilder2:

 1 public class ValidateCode_Style02:ValidateCodeBuilderBase
 2 {
 3         public override void CreateRandom()
 4         {
 5             //
 6         }
 7         
 8         public override void CreateImageBmp()
 9         {
10             //
11         }
12         
13         public override void DisposeImageBmp()
14         {
15             //
16         }
17         
18         public override void SetSession()
19         {
20             //
21         }
22         
23         public override ValidateCodeInfo GetResult()
24         {
25             return base.ValidateCodeInfo;
26         }
27     }

View Code

各自职责

Builder:	流程算法抽象类，负责定义流程算法具体每个步骤的函数；
ConcreteBuilder:	实现流程每个步骤的具体实现类，必须遵循流程算法抽象接口（实现Builder抽象类）；
Product:	按照一定的顺序执行完流程算法各个步骤后，在流程算法抽象类中将会提供一个GetResult()函数返回制造的产品就为Product.
Director:	用来确定流程算法步骤，并返回制造的产品。

各自特点

Director特点:

1. 结合Builder从而实现了解耦和依赖倒置;
2. 对算法步骤进行封装;
3. Director不关心流程步骤，只负责流程算法执行顺序，职责单一.

Builder特点：

1. 负责算法流程具体步骤的定义，具有总结能力，具有规范（模范）意义；

2. 不负责具体实现，从而结合Director达到解耦，依赖倒置。

调用：

这里我必须要附上，它的调用要注意，实例化的ConcreteBuilder时Client来负责的，这也正体现了Director解耦的实现，Director只接收一个抽象的Builder对象。

1 static void Main(string[] args)
2 {
3        // 实例化builder
4       ValidateCodeBuilderBase builder=new ValidateCode_Style01();
5       // 实例化director
6       ValidateCodeDirector director=new ValidateCodeDirector(builder);
7       // 生成验证码信息
8       ValidateCodeInfo validateInfo=director.MakeValidateCode();
9 }

比较（抽象工厂vs创建者模式）：

看起来很抽象工厂优点相似，不错，他们有相似指出就是都有类的实例化，但不同的的是，他们负责的重点不一样：

抽象工厂负责重点 ：注重类的创建，类的实例化是交给了工厂方法实例化，它负责了类的实例化------子类的创建封装在工厂方法中；

创建者模式负责重点：注重流程算法的操作步骤（Director），而Builder的子类（ConcreteBuilder）的实例化时由Client来实现的。

从这些方面来说我们可以说他们共同拥有创建型模式相似外，还有很大的区别，而且抽象工厂，创建的产品是多个系列的产品，而创建者确实一个确定的产品对象。

参考文档：《 http://www.codeproject.com/Articles/28309/Design-pattern-FAQ-Part-1-Training》

希望牛人们，给点指点和建议！