设计模式 ---> 创建型模式

建造者模式：

建造者模式也叫生成器模式，英文名称是：Builder Pattern

定义：

Separate the construction of a complex object from its representation so that the same construction process can create different representations.

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

背景：

在现实生活中，常常会有一些构成比较复杂的物体，它往往是由许多部分组成，这些部分由各个部门单独加工而成，最后再进行组装。例如：电脑的主机，就是由CPU，主板，硬盘，显卡，机箱等

实现：

我们可以将这些部分独立成一个个部门，分别封装一个方法去建造这些小物件。

具体角色：

1.抽象建造者： 根据需求定义产品的组成部分的建造方法；以规范具体的行为逻辑。 2.具体建造者： 根据抽象建造者定义的规范去具体实现建造物品的方法，以及得到最终产品的方法。 3.指挥者： 指挥具体建造者要建造那些物体。 4.产品： 最终的产品包含具体的属性。

代码实现：

using System;
using System.Collections.Generic;
using System.Text;

namespace BuilderPattern
{
    //客户类
    public class Customer
    {
        public static void Main(string[] args)
        {
            //创建指挥者指挥建造者具体工作
            Director director = new Director();
            //创建建造者建造产品
            BuilderAbstract builder = new Builder();

            //开始建造产品
            director.Construct();
            //产品在建造者中获得
            Computer computer = builder.GetComputer();

            //查看产品已经装好的组件
            computer.ComputerShow();
        }
    }

    //具体产品：主机
    public class Computer
    {
        //产品的组成
        private List<string> computerList;
        public List<string> ComputerList 
        { 
            get => computerList;
            set => computerList = value; 
        }

        //添加产品组成
        public void ComputerAdd(string part)
        {
            ComputerList.Add(part);
        }

        //展示已经装好的物体
        public void ComputerShow()
        {
            foreach (string item in ComputerList)
            {
                Console.WriteLine($"组件：{item} 已经装好了！");
            }
        }

    }

    //抽象建造者：定义建造的方法
    public abstract class BuilderAbstract
    {
        //建造CPU
        public abstract void BuildCPU();
        //建造显卡
        public abstract void BuildGraphicsCard();
        //建造硬盘
        public abstract void BuildHardDisk();
        //建造主板
        public abstract void BuildMainBoard();
        //建造机箱
        public abstract void BuildChassis();
        //组装主机
        public abstract Computer GetComputer();
    }

    //具体建造者：实现方法
    public class Builder : BuilderAbstract
    {
        Computer computer = new Computer();
        //建造CPU
        public override void BuildCPU()
        {
            computer.ComputerAdd("CPU");
        }
        //建造显卡
        public override void BuildGraphicsCard()
        {
            computer.ComputerAdd("显卡");
        }
        //建造硬盘
        public override void BuildHardDisk()
        {
            computer.ComputerAdd("硬盘");
        }
        //建造主板
        public override void BuildMainBoard()
        {
            computer.ComputerAdd("主板");
        }
        //建造机箱
        public override void BuildChassis()
        {
            computer.ComputerAdd("机箱");
        }
        //获得组装好的主机
        public override Computer GetComputer()
        {
            return computer;
        }
    }

    //指挥者：指挥具体的建造者建造产品的组成部分
    public class Director
    {
        //指挥命令
        public void Construct(BuilderAbstract builder)
        {
            builder.BuildCPU();
            builder.BuildGraphicsCard();
            builder.BuildHardDisk();
            builder.BuildMainBoard();
            builder.BuildChassis();
        }
    }
}

建造者模式实现要点：

在建造者模式中，客户端是直接与指挥者进行通信的，客户端只要求获得的具体产品，而不关心产品的具体构成与实现。因此要将产品的组成封装起来，不对客户端进行暴露，从而实现了 迪米特法则 ，也就是最少知识原则。

建造者： 需要一个抽象类从而方便对外开放扩展，如果要增加一个不同品牌的主机，那么只需要重新构建一个具体的建造者，而不用修改原来的代码，实现了 开闭原则。

产品： 是不需要一个抽象类的，因为一个产品的具体组成差异很大，无法完全提炼一个抽象产品类。

指挥者： 隔绝客户端与建造者的通信，避免客户端知道生产产品的具体行为，指挥者也解决了代码膨胀的问题，如果具体的建造者有1000个，那么就要在客户端中调用1000次生产CPU的方法，1000次生产主板的方法等，造成代码膨胀，而使用指挥者很好的解决了这个问题。