目录：设计模式之小试牛刀
源码路径：Github-Design Pattern

---

定义：（Builder Pattern）

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

类图：

建造者模式通用类图

启示：

采购经理要采购一批台式电脑，为了节约公司成本，决定组装。但是对于怎么组装，采购经理不知道也不关心，所以就指派装机商组装。第一次采购的电脑是组装的HP的台式机，
第二次采购经理决定换个品牌，组装DELL的台式机。对于怎么组装HP、DELL台式机，采购经理不关心。

参与者：

Builder
为创建一个Product对象的各个部件指定抽象接口。
ConcreteBuilder
实现Builder的接口以构造和装配该产品的各个部件。
定义并明确它所创建的表示。
提供一个检索产品的接口。
Director
构造一个使用Builder接口的对象。
Product
表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。
包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

代码：

先看看产品Product，电脑的实现。

    /// <summary>
    /// 产品类
    /// </summary>
    public class Computer
    {
        /// <summary>
        /// 品牌
        /// </summary>
        public string Band { get; set; }

        /// <summary>
        /// 电脑组件列表
        /// </summary>
        private List<string> assemblyParts = new List<string>();

        /// <summary>
        /// 组装部件
        /// </summary>
        /// <param name="partName">部件名称</param>
        public void AssemblePart(string partName)
        {
            this.assemblyParts.Add(partName);
        }

        public void ShowSteps()
        {
            Console.WriteLine("开始组装『{0}』电脑:", Band);
            foreach (var part in assemblyParts)
            {
                Console.WriteLine(string.Format("组装『{0}』;", part));
            }

            Console.WriteLine("组装『{0}』电脑完毕！", Band);
        }
    }

接下来看Builder角色，即电脑组装商抽象类。

    /// <summary>
    /// 建造者（模拟装机过程）,也可通过接口实现
    /// Director不关心具体组装的细节，所以将具体的组装细节方法标记为protected
    /// </summary>
    public abstract class Builder
    {
        /// <summary>
        /// 组装主机
        /// </summary>
        protected abstract void BuildMainFramePart();

        /// <summary>
        /// 组装显示器
        /// </summary>
        protected abstract void BuildScreenPart();

        /// <summary>
        /// 组装输入设备（键鼠）
        /// </summary>
        protected abstract void BuildInputPart();

        /// <summary>
        /// 获取组装电脑
        /// 由具体的组装类决定组装顺序
        /// </summary>
        /// <returns></returns>
        public abstract Computer BuildComputer();
    }

再看看具体的ConcreteBuilder角色，HP电脑组装商的实现

    /// <summary>
    /// 惠普电脑组装商
    /// </summary>
    public class HpBulider : Builder
    {
        Computer hp = new Computer() { Band = "惠普" };

        protected override void BuildMainFramePart()
        {
            hp.AssemblePart("主机");
        }

        protected override void BuildScreenPart()
        {
            hp.AssemblePart("显示器");
        }

        protected override void BuildInputPart()
        {
            hp.AssemblePart("键鼠");
        }

        /// <summary>
        /// 决定具体的组装步骤
        /// </summary>
        /// <returns></returns>
        public override Computer BuildComputer()
        {
            BuildMainFramePart();
            BuildScreenPart();
            BuildInputPart();
            return hp;
        }
    }

最后只等指挥者Director一声令下，组装电脑。看看指挥者的实现。

    /// <summary>
    /// 指挥者（采购经理）
    /// </summary>
    public class Director
    {
        public Computer Construct(Builder builder)
        {
           return builder.BuildComputer();
        }
    }

场景类

        static void Main(string[] args)
        {
            Director director = new Director();
            HpBulider hpBuilder = new HpBulider();
            DellBulider dellBuilder =new DellBulider();

            //组装一批惠普电脑
            Computer hp =director.Construct(hpBuilder);
            hp.ShowSteps();

            Console.ReadLine();

            //组装一批戴尔电脑
            Computer dell = director.Construct(dellBuilder);
            dell.ShowSteps();

            Console.ReadLine();
        }

运行结果

优缺点：

建造者隐藏了具体产品的组装过程，所以要改变一个产品的内部表示，只需要再实现一个具体的建造者就可以了，从而能很好地应对产品部件的需求变化。

抽象工厂模式解决了“系列产品”的需求变化，而建造者模式解决的是 “产品部分” 的需要变化。

应用场景：

创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。建造者模式关注的是零件类型和装配工艺（顺序）。最主要的功能是基本方法的调用顺序安排。