设计模式之建造者模式（Builder）

建造者模式定义

代码实现

    /// <summary>
    /// 工人抽象
    /// </summary>
    public abstract class AbstractBuilder
    {

        public abstract void Engine();

        public abstract void Wheels();

        public abstract void Light();

        public abstract Car Car();
    }

   /// <summary>
    /// 比亚迪工人
    /// </summary>
    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 = "比亚迪*唐"
            };
        }
    }

   /// <summary>
    /// 福特工人
    /// </summary>
    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"
            };
        }
    }

    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();
        }
    }

要点总结

心得体会

建造者模式与抽象工厂模式很类似，但是建造者模式中的一系列对象是为了按照固定的算法流程组装为一个大的对象，需要一个Director类来实现这个组装的过程。所以建造者模式是为了实现更复杂对象的创建。

类中哪里不稳定就把它整成虚函数，虚函数如果还不稳定，就把虚函数的参数和返回值再弄基类子类，总能从变化中找到稳定的状态。