在软件
系统中，有时候会面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂的对象的各个部分可能面临着剧烈的变化，但是把他们组合在一起的算法很稳定。
提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求的改变而改变
2、意图：
将复杂对象的构建与其表示相分离（客户不关心这个复杂对象产品内部是怎么创建的），使得同样的构建工程可以创建不同的表示。
3、结构图
4、现实的简易的例子
1、客户找到包工头,要求建一个房子,
2、包工头找到不同的建筑队(Builder)来建筑房子的每个部分,建好房子后,交付给客户
3、客户不关心房子的建造细节,由包工头负责管理房子建造的细节
5、代码演示
1》第一种：含有指导者（对象的各个部分的创建顺序有main函数决定）
复制代码
1 //字部分A
2 public class A
3 {
4 }
5 //字部分B
6 public class B
7 {
8 }
9 //要创建的复杂的对象产品
10 public class Product
11 {
12 public A partA { set; get; }
13
14 public B partB { set; get; }
15 }
16 //创建者
17 public class Builder
18 {
19 private Product p = new Product();
20
21 //将创建的方法公开给 外面，这样创建的顺序就可以由指导者决定
22 public void CreatA()
23 {
24 p.partA = new A();
25 }
26
27 public void creatB()
28 {
29 p.partB = new B();
30 }
31 //最后得到创建的产品
32 public Product GetResult()
33 {
34 return p;
35 }
36 }
37
38 public class Directer
39 {
40 private Builder builder = new Builder();
41
42 //具体的创建过程（子对象的创建顺序）由 指导者 来决定
43 public void Contract()
44 {
45 builder.creatB();
46 builder.CreatA();
47 }
48 public Product GetResult()
49 {
50 return builder.GetResult();
51 }
52 }
复制代码
主函数调用：
1 Product p = null;//定义一个产品对象用来接收导者创建出来的产品
2 Directer directer = new Directer();
3 directer.Contract();//创建产品
4 p = directer.GetResult();
2》第二种：不含指导者（将对象的创建过程在创建者内部就已经决定好了）
复制代码
1 public class Product
2 {
3 public PartA partA { set; get; }
4 public PartB partB { set; get; }
5 }
6
7 //部分对象怎么改变，已经封装起来，不进行考虑了
8 public class PartA
9 {
10 }
11 public class PartB
12 {
13 }
14
15 public class Builder
16 {
17 private Product product = new Product();
18
19 //创建 部分对象 如果 在增加 部分，那么就 进行扩展一个创建他的方法就可以了
20 private void BuildPartA()
21 {
22 product.partA = new PartA();
23 }
24
25 private void BuildPartB()
26 {
27 product.partB = new PartB();
28 }
29
30 public void Contract()
31 {
32 BuildPartA();
33 BuildPartB();
34 }
35
36 public Product GetResult()
37 {
38 return product;
39 }
40 }
复制代码
总结：Builder模式是将复杂对象的各个字部分的创建封装了起来，不管这个子对象怎么变化，都不会影响到那个复杂的对象，因为Builder已经将创建和表示隔离开了。
6、创建者角色和产品角色合并
1、具体建造者角色和产品角色合并，从而使得产品自己就是自己的建造者。（在Product 内部含有对每个 子部分对象的创建方法）
2、这样做混淆了对象的建造者和对象本身，但是有时候一个产品对象有着固定的几个零件，而且永远只有这几个零件，此时将产品类和建造类合并，可以使系统简单易读。
下面是“创建者角色和产品角色合并”的最好诠释
7、.Net中简化的Builder模式（StringBuilder）
System.Text.StringBuilder sb = new StringBuilder();
sb.Append("aa");//添加的子对象部分(这就是创建 子对象的部分)
sb.Append("bb");(这个就对应 GetResult())
string str= sb.ToString();//最终 都演变成 最后一种形式
8、效