建造者模式

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

情景：在软件系统中，有时需要创建一个复杂对象，并且这个复杂对象由其各部分子对象通过一定的步骤组合而成。例如一个采购系统中，如果需要采购员去采购一批电脑时，在这个实际需求中，电脑就是一个复杂的对象，它是由CPU、主板、硬盘、显卡、机箱等组装而成的，如果此时让采购员一台一台电脑去组装的话真是要累死采购员了，这里就可以采用建造者模式来解决这个问题，我们可以把电脑的各个组件的组装过程封装到一个建造者类对象里，建造者只要负责返还给客户端全部组件都建造完毕的产品对象就可以了。然而现实生活中也是如此的，如果公司要采购一批电脑，此时采购员不可能自己去买各个组件并把它们组织起来，此时采购员只需要像电脑城的老板说自己要采购什么样的电脑就可以了，电脑城老板自然会把组装好的电脑送到公司

先来实现这个例子

/// <summary>
    /// 电脑类
    /// </summary>
    public class Computer
    {
        //电脑组件集合
        public List<string> parts = new List<string>();
        //把单个组件添加到电脑组件集合中
        public void Add(string part)
        {
            parts.Add(part);
        }

        public void Show()
        {
            Console.WriteLine("电脑开始在组装......");
            foreach (var item in parts)
            {
                Console.WriteLine(string.Format("组件{0}已经装好", item));
            }
            Console.WriteLine("电脑组装好了");
        }
    }
    /// <summary>
    /// 建造者抽象类
    /// </summary>
    public abstract class Builder
    {
        //装Cpu
        public abstract void BuilderCpu();
        //装主板
        public abstract void BuilderMain();
        //获得组装好的电脑
        public abstract Computer GetComputer();

    }

    /// <summary>
    /// 指挥创建过程的类（也就是老板，老板指挥员工去组装电脑）
    /// 建造模式的指挥者
    /// </summary>
    public class Director
    {
        public void Construct(Builder builder)
        {
            builder.BuilderCpu();
            builder.BuilderMain();
        }
    }

    /// <summary>
    /// 具体创建者，这里只安装电脑的某个员工
    /// </summary>
    public class PersonBuilder1 : Builder
    {
        Computer computer = new Computer();
        //安装一个新的Cpu
        public override void BuilderCpu()
        {
            computer.Add("CPU1");
        }
        //安装一个新的主板
        public override void BuilderMain()
        {
            computer.Add("Main1");
        }
        //用于得到组装好的电脑
        public override Computer GetComputer()
        {
            return computer;
        }
    }

    /// <summary>
    /// 具体创建者，这里只安装电脑的某个员工
    /// </summary>
    public class PersonBuilder2 : Builder
    {
        Computer computer = new Computer();
        //安装一个新的Cpu
        public override void BuilderCpu()
        {
            computer.Add("CPU2");
        }
        //安装一个新的主板
        public override void BuilderMain()
        {
            computer.Add("Main2");
        }
        //用于得到组装好的电脑
        public override Computer GetComputer()
        {
            return computer;
        }
    }

注释很详细就不过多解释，

客户端

 static void Main(string[] args)
        {
            Director director = new Director();
            Builder b1 = new PersonBuilder1();
            Builder b2 = new PersonBuilder2();

            director.Construct(b1);
            Computer computer = b1.GetComputer();
            computer.Show();
        }

这样就实现了建造者模式，注释很多就不解释了

但是这个不太形象，在类库中应该只有一个建造者的实现

改造：

改变建造者类：

 public class Person
    {
        //实例化电脑类
        private Computer computer = new Computer();

        public void BulidA()
        {
            computer.Add("PartA");
        }

        public void BulidB()
        {
            computer.Add("PartB");
        }

        public Computer GetComputer()
        {
            return computer;
        }
        //指挥者
        public void construt()
        {
            BulidA();
            BulidB();
        }
    }

　客户端调用

   static void Main(string[] args)
        {
            Person p = new Person();
            p.construt();
            Computer computer = p.GetComputer();
            computer.Show();
        }

　总结：将一个复杂对象的构建与它的表示分离，使的同样的构建过程可以创建不同的表示。建造者模式的本质是使组装过程（用指挥者类进行封装，从而达到解耦的目的）和创建具体产品解耦,使我们不用去关心每个组件是如何组装的。

转载于:https://www.cnblogs.com/liu23/p/9080486.html