设计模式-建造者模式

抽象工厂模式：https://www.cnblogs.com/Kyle-Wang/p/16097677.html

一、建造者模式引入

　　建造者模式和抽象工厂模式很类似。

　　1、相同点：

　　　　都是一个工厂内部并不只是创建一种对象，而是可以创建多种对象。

　　2、不同点：

　　　　抽象工厂创建的多种对象间是没有关联的，对象间不相互依赖，比如抽象工厂例子里的，主公、武将，他们可以单独创建出来。

　　　　建造者创建的多种对象是有关联的，某个对象的创建，必须依赖其他对象的创建，具有顺序、组合关系。比如，创建一辆车，建造者模式里必须要可以创建引擎、车轮、轮毂、车架、车灯之类的，轮毂必须先创建出来，再组装车轮。

　　　　正因为建造者更加的复杂，为了使调用方不用关心内部很复杂的对象创建、组装。引出了一个新角色：设计师（或者产品经理、导演）。调用方负责使用建造者来设计创建客户所需的对象，客户只需要向设计师拿就行了。

　　3、总结：

　　　　抽象工厂适用于创建复杂对象，而建造者模式适用于创建更复杂的对象。

二、建造者模式实现

　　1、定义建造者抽象类

public abstract class AbstractBuilder
    {

        public abstract void Engine();

        public abstract void Wheels();

        public abstract void Light();

        public abstract Car Car();
    }

　　2、定义不同建造者实现类

　　　　比亚迪建造者类

public class BuilderBYD : AbstractBuilder
    {
        private Engine _Engine = null;
        private Wheels _Wheels = null;
        private Light _Light = null;

        public override void Engine()
        {
            this._Engine = new Engine()
            {
                Name = "_Engine"
            };

            Console.WriteLine("{0} build Engine", this.GetType().Name);
        }

        public override void Wheels()
        {
            this._Wheels = new Wheels()
            {
                Name = "_Wheels"
            };
            Console.WriteLine("{0} build Wheels", this.GetType().Name);
        }

        public override void Light()
        {
            this._Light = new Light()
            {
                Name = "_Light"
            };
            Console.WriteLine("{0} build Light", this.GetType().Name);
        }

        public override Car Car()
        {
            Console.WriteLine("组装 {0} {1} {2}", this._Engine, this._Light, this._Wheels);
            Console.WriteLine("{0} build 比亚迪*唐", this.GetType().Name);

            return new Car(this._Engine, this._Light, this._Wheels)
            {
                Name = "比亚迪*唐"
            };
        }
    }

　　　　福特建造者类

public class BuilderFord : AbstractBuilder
    {
        private Engine _Engine = null;
        private Wheels _Wheels = null;
        private Light _Light = null;

        public override void Engine()
        {
            this._Engine = new Engine()
            {
                Name = "_Engine"
            };

            Console.WriteLine("{0} build Engine", this.GetType().Name);
        }

        public override void Wheels()
        {
            this._Wheels = new Wheels()
            {
                Name = "_Wheels"
            };
            Console.WriteLine("{0} build Wheels", this.GetType().Name);
        }

        public override void Light()
        {
            this._Light = new Light()
            {
                Name = "_Light"
            };
            Console.WriteLine("{0} build Light", this.GetType().Name);
        }

        public override Car Car()
        {
            Console.WriteLine("组装 {0} {1} {2}", this._Engine, this._Light, this._Wheels);
            Console.WriteLine("{0} build Mondeo", this.GetType().Name);

            return new Car(this._Engine, this._Light, this._Wheels)
            {
                Name = "Mondeo"
            };
        }
    }

　　3、定义设计师类，

　　　　

public class Director
    {
        private AbstractBuilder _AbstractBuilder = null;
        public Director(AbstractBuilder builder)
        {
            this._AbstractBuilder = builder;
        }

        public Car GetCar()
        {
            this._AbstractBuilder.Engine();
            this._AbstractBuilder.Wheels();
            this._AbstractBuilder.Light();

            return this._AbstractBuilder.Car();
        }
    }

　　4、调用方式

                {
                    AbstractBuilder builder = new BuilderBYD();

                    Director director = new Director(builder);
                    director.GetCar();
                }


                {
                    AbstractBuilder builder = new BuilderFord();
                    Director director = new Director(builder);
                    director.GetCar();
                }