c#设计模式-创建性模式-2.建造者模式

Posted 2021-05-24 mr.chenyuelin

建造者模式：将一个复杂对象将构造与其表示分离，使得同样构造过程创建不同表示

例子，一个车由窗户、引擎、车轮等等子物体构成，用户选择好对应的车子品牌之后，指导者就建造哪个牌子的车

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 建造者模式
{
    //指挥者，类似老板，可在客户端决定建造哪个牌子的车
    public class Director
    {
        public void Construct(Builder builder)
        {
            //一般都是有顺序的
            builder.BuildCarDoor();
            builder.BuildCarEngine();
            builder.BuildCarWheel();
        }
    }
    //汽车类，
    public sealed class Car
    {
        //存产品的子物件
        private List<string> parts = new List<string>();
        public void Add(string part)
        {
            parts.Add(part);
        }
        public void Show()
        {
            Console.WriteLine("汽车开始组装");
            foreach (string item in parts)
            {
                Console.WriteLine("组件" + item + "已装好");
            }
            Console.WriteLine("汽车组装好了");
        }
    }
    //抽象建造者
    public abstract class Builder
    {
        //装窗户
        public abstract void BuildCarDoor();
        //装车轮
        public abstract void BuildCarWheel();
        //装引擎
        public abstract void BuildCarEngine();
        //当然还有其它部件

        //获取组装好的汽车
        public abstract Car GetCar();
    }
    //具体建造者，别克
    public sealed class BuickBuilder : Builder
    {
        Car buickCar = new Car();
        public override void BuildCarDoor()
        {
            buickCar.Add("buick's Door");
        }
        public override void BuildCarEngine()
        {
            buickCar.Add("buick's Engine");
        }
        public override void BuildCarWheel()
        {
            buickCar.Add("buick's Wheel");
        }
        public override Car GetCar()
        {
            return buickCar;
        }
    }
    //
    public sealed class AoDiBuilder : Builder
    {
        Car aoDiCar = new Car();
        public override void BuildCarDoor()
        {
            aoDiCar.Add("AoDi's Door");
        }
        public override void BuildCarEngine()
        {
            aoDiCar.Add("AoDi's Engine");
        }
        public override void BuildCarWheel()
        {
            aoDiCar.Add("AoDi's Wheel");
        }
        public override Car GetCar()
        {
            return aoDiCar;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Director director = new Director();

            Builder buickBuilder = new BuickBuilder();            
            director.Construct(buickBuilder);
            Car buickCar = buickBuilder.GetCar();
            buickCar.Show();
            //我觉得上面的这个牌子不好开，换个牌子开
            Builder aoDiBuilder = new AoDiBuilder();
            director.Construct(aoDiBuilder);
            Car aodiCar = aoDiBuilder.GetCar();
            aodiCar.Show();
            Console.ReadKey();
        }
    }
}

用户是与指挥者交流的，然后指挥者再将具体的请求委派给具体的建造者去实现，客户并不知道产品的具体实现的。

为什么产品类并没有提炼出来一个抽象类，因为比如我这造自行车和造汽车所需要的零件能一样吗，许多方法都会不一样。

抽象工厂模式是“系列产品”的生产，如鼠标，键盘，都可以与电脑配套使用
而建造者模式是“产品部分”的生产，一个汽车需要很多零件，零件不可缺少，汽车少了轮胎能走吗，电脑少了键盘，我也能玩呀，虽然可玩性降低了

建造者模式的优点：

1.实例的构建具体到组件层次，方便控制细节；

2.具体的建造者相互独立，易于扩展。

3.客户不需要知道产品具体实现过程

建造者模式的缺点：

当组件的组合种类很多时，需要创建很多的具体建造者类。