【设计模式】建造者模式

建造者模式（Builder Pattern）是属于创建型模式，又叫生成器模式。将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
建造者模式的结构中引入了一个指挥者类Director， 该类的作用主要有两个：

1.它隔离了客户与生产过程,指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型
2.它负责控制产品的生成过程,调用先后次序,并返回一个完整的产品对象

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

应用实例： StringBuilder。

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。

使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

 

C#代码：

using System;

namespace ConsoleApp2
{
    public class Computer
    {
        private string _logo;//logo;
        private string _cpu;//中央处理器
        private string _fan;//风扇
        private string _memory;//内存卡
        private string _hardDisk;//硬盘

        public string Logo { get => _logo; set => _logo = value; }
        public string Cpu { get => _cpu; set => _cpu = value; }
        public string Fan { get => _fan; set => _fan = value; }
        public string Memory { get => _memory; set => _memory = value; }
        public string HardDisk { get => _hardDisk; set => _hardDisk = value; }

        public override string ToString()
        {
            return string.Format("logo:{0}, cpu:{1}, fan:{2}, memory:{3}, hardDisk:{4}", _logo, _cpu, _fan, _memory, _hardDisk);
        }
    }


    public abstract class ComputerBuilder
    {
        public abstract void BuildLogo();
        public abstract void BuildCpu();
        public abstract void BuildFan();
        public abstract void BuildMemory();
        public abstract void BuildHardDisk();
        public abstract Computer createComputer();

    }

    public class AsusComputerBuilder : ComputerBuilder
    {
        private Computer _computer = new Computer();

        
        public override void BuildCpu()
        {
            _computer.Cpu = "AMD";
        }

        public override void BuildFan()
        {
            _computer.Fan = "DEEP COOL";
        }

        public override void BuildHardDisk()
        {
            _computer.HardDisk = "TOSHIBA";
        }

        public override void BuildLogo()
        {
            _computer.Logo = "ASUS";
        }

        public override void BuildMemory()
        {
            _computer.Memory = "SAMSUNG";
        }

        public override Computer createComputer()
        {
            return _computer;
        }
    }

    public class HpComputerBuilder : ComputerBuilder
    {
        private Computer _computer = new Computer();
        public override void BuildCpu()
        {
            _computer.Cpu = "Intel";
        }

        public override void BuildFan()
        {
            _computer.Fan = "Cooler Master";
        }

        public override void BuildHardDisk()
        {
            _computer.HardDisk = "WD";
        }

        public override void BuildLogo()
        {
            _computer.Logo = "HP";
        }

        public override void BuildMemory()
        {
            _computer.Memory = "KingSton";
        }

        public override Computer createComputer()
        {
            return _computer;
        }
    }

    /// <summary>
    /// 建造者模式的结构中引入了一个指挥者类Director，
    /// 该类的作用主要有两个：
    /// 1.它隔离了客户与生产过程,指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型，
    /// 2.它负责控制产品的生成过程,调用先后次序,并返回一个完整的产品对象
    /// </summary>
    public class ComputerDirector
    {
        private ComputerBuilder _computerBuilder;
        public ComputerDirector(ComputerBuilder computerBuilder)
        {
            _computerBuilder = computerBuilder;
        }

        public Computer Construct()
        {
            _computerBuilder.BuildLogo();
            _computerBuilder.BuildCpu();
            _computerBuilder.BuildFan();
            _computerBuilder.BuildMemory();
            _computerBuilder.BuildHardDisk();

            return _computerBuilder.createComputer();
        }
    }


    public class Program
    {
        static void Main(string[] args)
        {
            ComputerDirector director;
            director = new ComputerDirector(new AsusComputerBuilder());
            Computer asusComputer = director.Construct();


            director = new ComputerDirector(new HpComputerBuilder());
            Computer hpComputer = director.Construct();

            Console.WriteLine(asusComputer);
            Console.WriteLine(hpComputer);


            Console.Read();
        }
    }
}