建造者模式

定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以建造不同的表示。

建造者模式的结构

Builder(抽象建造者): 它为创建一个产品Product对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类方法是BuildPartX(),他们用于创建复杂对象的各个部件，另一类方法是GetResult()，它们用于返回复杂对象，Builder可以是抽象类，也可以是接口。

ConcreteBuilder(具体建造者)： 它实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确所创建的复杂对象，还可以提供一个方法返回创建好的复杂产品对象(该方法可以由抽象建造者实现)。

Product(产品)： 它是被构建的复杂对象，包含多个组成部件，具体构造者创建该产品内部表示并定义它的装配过程。

Director(指挥者)： 指挥者又称为导演类，它负责安排复杂对象的构造次序，指挥者与抽象建造者之间存在关联。可以在其Construct()建造方法中调用建造者对象的部件构造和装备方法，完成复杂对象的构造。客户端一般只需要与指挥者进行交互，在客户端确认具体建造者的类型，并实例化具体建造者对象（也可以通过配置文件和反射机制），然后通过指挥者类的构造函数或者Setter方法将对象传入指挥者类中。有些时候Director不是必要的，例如你可以直接在抽象类中完成这个操作。

撸码

汽车通常是由发动机、底盘、车身和电气设备4大部分组成。

今天这个例子就以汽车为例。

Builder ：CarBuilder

ConcreteBuilder ：BenzCarBuilder,BMWCarBuilder,AudiCarBuilder

Product :汽车

Director ：CarController

Product

首先好确认车子的组成部分（属性）

 /// <summary>
    /// Product
    /// </summary>
    public class Car
    {

        /// <summary>
        /// 发动机
        /// </summary>
        public string Engine { get; set; }

        /// <summary>
        /// 底盘
        /// </summary>
        public string Chassis { get; set; }

        /// <summary>
        /// 车声
        /// </summary>
        public string Body { get; set; }
        /// <summary>
        /// 电气设备
        /// </summary>
        public string Electrical { get; set; }


    }

Builder

抽象建造者类

/// <summary>
    /// 抽象建造者
    /// </summary>
    public abstract class CarBuilder
    {
        protected Car _car;

        /*
         抽象方法
         */
        public abstract void BuilderEngine();
        public abstract void BuilderChassis();
        public abstract void BuilderBody();
        public abstract void BuilderElectrical();


        public CarBuilder()
        {
            _car = new Car();
        }


        public Car CreateCar()
        {
            return _car;
        }

ConcreteBuilder

具体的实现，这里为了避免代码看起来很多我就只放两个实现的Builder。

Audi

public class AudiCarBuilder : CarBuilder
    {
        public override void BuilderBody()
        {
            _car.Body = "豪华车身";
        }

        public override void BuilderChassis()
        {
            _car.Chassis = "贵族底盘";
        }

        public override void BuilderElectrical()
        {
            _car.Electrical = "史诗级电气设备，100000000w超级喷射";
        }

        public override void BuilderEngine()
        {
            _car.Engine = "行星级发动机";
        }
    }

Benz

 public class BenzCarBuilder : CarBuilder
    {
        public override void BuilderBody()
        {
            _car.Body = "镶钻车身";
        }

        public override void BuilderChassis()
        {
            _car.Chassis = "真空底盘";
        }

        public override void BuilderElectrical()
        {
            _car.Electrical = "100000000w超级喷射";
        }

        public override void BuilderEngine()
        {
            _car.Engine = "恒星级发动机";
        }
    }

CarController（指挥者）

 /// <summary>
    /// 指挥者
    /// </summary>
    public class CarController
    {
        /// <summary>
        /// 构建一辆汽车
        /// </summary>
        /// <param name="builder"></param>
        /// <returns></returns>
        public Car Construct(CarBuilder builder)
        {

            //可以调整你想要的顺序
            builder.BuilderBody();
            builder.BuilderChassis();
            builder.BuilderElectrical();
            builder.BuilderEngine();

            return builder.CreateCar();
        }
    }

最后测试一下

                CarController controller = new CarController();

                //造一辆奥迪车
                Car car = controller.Construct(new AudiCarBuilder());

                Console.WriteLine(car.Body);
                Console.WriteLine(car.Chassis);
                Console.WriteLine(car.Electrical);
                Console.WriteLine(car.Engine);

结果

当然如果你的Car很多，就可以用一个枚举或者工厂去处理它。

总结

建造者模式的优点

1.在建造者模式，客户端不必知道产品内部组成的细节，将产品本身和产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。

2.每一个具体建造者都相对独立，与其他的具体构造着无关，因此可以很方便的地替换具体建造者或增加新的建造者，用户使用不同的具体建造者即可获得不同的产品对象。由于建造者类针对抽象建造者编程，增加新的建造者无需修改原有类库的代码，系统扩展方便，符合开闭原则。

3.用户可以更加精细地控制产品的创建过程，将复杂产品的创建步骤分解到不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

建造者模式的缺点

1.建造者模式所创建的产品一般具有较多的相同点，其组成方式很相似，如果产品之间的差异性很大，例如很多组成部分不相同，则不适合使用建造者模式，因此其适用范围收到一定的限制。

2.如果产品的内部变化复杂，可能需要定义很多具体建造者来实现这种变化，导致系统变得很庞大，增加系统的理解难度和运行成本。

适用环境

1.需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员变量。

2.需要生成的产品对象属性相互依赖，需要指定生成顺序。

3.对象的创建过程独立于创建该对象的类。在建造者模式中通过引入指挥者类，将创建过程封装到指挥者类中，而不是在建造者类和客户类。

4.隔离复杂对象的创建和使用，并使得相同的创建过程创建不同的产品。