设计模式 --builder pattern

• builder pattern

在建造者模式中， 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
角色分析：

• Builder： 为创建一个产品对象的各个部件指定抽象接口；
• Director： 负责安排复杂对象的建造次序，director与builder之间存在关联关系，可以在其construct()建造方法中调用builder对象的部件构造与装配方法，完成复杂对象的建造
• ConcreteBuilder： 实现了Builder接口，实现各个部件的构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象；
• product：是被构建的复杂对象，包含多个组成部件

dai

• 代码示例

/*
 *builder pattern 
 * 在客户端代码中，无须关心产品对象的具体组装过程
 * 建造者模式将复杂对象的构建与对象的表现分离开来，这样使得同样的构建过程可以创建出不同的表现
 */
using System;
using System.Collections.Generic;

namespace Pattern03
{

    class Program
    {

        static void Main(string[] args)
        {


            // Create director and builders

            Director director = new Director();

            Builder b1 = new ConcreteBuilder1();
            Builder b2 = new ConcreteBuilder2();

            // Construct two products

            director.Construct(b1);
            Product p1 = b1.GetResult();
            p1.Show();

            director.Construct(b2);
            Product p2 = b2.GetResult();
            p2.Show();

           

            Console.ReadKey();

        }

    }

    /// <summary>
    /// Director class::constructs an object using the Builder interface 
    /// 一方面它隔离了客户与生产过程；另一方面它负责控制产品的生成过程。
    ///  director  针对 bulider 编程，
    /// </summary>
    class Director
    {
        public void Construct(Builder builder)
        {
            builder.BuilderPartA();
            builder.BuilderPartB();
        }


    }
    /// <summary>
    /// Builder class:specifies an abstract interface for creating parts of a Product object
    /// 定义了产品的创建方法和返回方法
    /// </summary>
    abstract class Builder
    {
        public abstract void BuilderPartA();
        public abstract void BuilderPartB();
        public abstract Product GetResult();
    }
    class ConcreteBuilder1 : Builder
    {
        public Product _product = new Product();
        public override void BuilderPartA()
        {
            _product.Add("PartA");
        }

        public override void BuilderPartB()
        {
            _product.Add("PartB");   
        }

        public override Product GetResult()
        {
            return _product;
           
        }
    }
    class ConcreteBuilder2 : Builder
    {
        public Product _product = new Product();
        public override void BuilderPartA()
        {
            _product.Add("PartX"); 
        }
        public override void BuilderPartB()
        {
            _product.Add("PartY");
        }
        public override Product GetResult()
        {
            return _product;
        }
    }

    /// <summary>
    /// product class
    /// </summary>
    class Product
    {
        public List<string> parts = new List<string>();
        public void Add(string part)
        {
            parts.Add(part);
        }
        public void Show()
        {
            Console.WriteLine("Product Parts.......");
            foreach (string s in parts)
            {
                Console.WriteLine("part :"+s);
            }
        }
    }


}

• 与抽象工厂模式的区别
  • 建造者模式返回一个组装好的完整产品 ；
  • 抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构构成了一个产品族。

如果将抽象工厂模式看成 汽车配件生产工厂 ，生产一个产品族的产品，那么建造者模式就是一个 汽车组装工厂 ，通过对部件的组装可以返回一辆完整的汽车。

• 实际中的应用

/*
 *builder pattern 
 * 在客户端代码中，无须关心产品对象的具体组装过程
 * 建造者模式将复杂对象的构建与对象的表现分离开来，这样使得同样的构建过程可以创建出不同的表现
 */
using System;
using System.Collections.Generic;

namespace Pattern03
{

    class Program
    {

        static void Main(string[] args)
        {


            VehicleBuilder builder=new SoocterVehicle();
            Shop shop = new Shop();

            shop.Construct(builder);
            builder.Vehicle.Show();


            builder = new CarVehicle();
            shop.Construct(builder);
            builder.Vehicle.Show();


            builder = new MotorCircleVehicle();
            shop.Construct(builder);
            builder.Vehicle.Show();





            Console.ReadKey();

        }

    }

    /// <summary>
    /// Director class::constructs an object using the Builder interface 
    /// 一方面它隔离了客户与生产过程；另一方面它负责控制产品的生成过程。
    ///  director  针对 bulider 编程，
    /// </summary>
    class Shop
    {
        public void Construct(VehicleBuilder builder)
        {
            builder.BuilderFrame();
            builder.BuilderEngine();
            builder.BuilderWheels();
            builder.BuilderDoors();

        }


    }
    /// <summary>
    /// Builder class:specifies an abstract interface for creating parts of a Product object
    /// 定义了产品的创建方法和返回方法
    /// </summary>
    abstract class VehicleBuilder
    {
        protected Vehicle vehicle;
        public Vehicle Vehicle
        {
            get { return vehicle; }
        }
        public abstract void BuilderFrame();
        public abstract void BuilderEngine();
        public abstract void BuilderWheels();
        public abstract void BuilderDoors();
      
    }
    #region concreteBuilder
    class MotorCircleVehicle :VehicleBuilder 
    {
        public MotorCircleVehicle()
        {
            vehicle = new Vehicle("MotoCircle Vehicle");
        }

        public override void BuilderFrame()
        {
            vehicle["frame"] = "MotorCircle frame";
        }

        public override void BuilderEngine()
        {
            vehicle["engine"] = "500 cc";
        }

      
        public override void BuilderWheels()
        {
            vehicle["wheels"] = "2";
        }
        public override void BuilderDoors()
        {
            vehicle["doors"] = "0";
        }
    }
    class SoocterVehicle : VehicleBuilder
    {

        public SoocterVehicle()
        {
            vehicle = new Vehicle("soocter Vehicle");
        }
        public override void BuilderFrame()
        {
            vehicle["frame"] = "soocter vehicle";
        }
        public override void BuilderEngine()
        {
            vehicle["engine"] = "300 cc";
        }
        public override void BuilderWheels()
        {
            vehicle["wheels"] = "2";
        }
        public override void BuilderDoors()
        {
            vehicle["doors"] = "0";
        }
    }
    class CarVehicle : VehicleBuilder
    {
        public CarVehicle()
        {
            vehicle = new Vehicle("car vehicle");
        }
        public override void BuilderFrame()
        {
            vehicle["frame"] = "car vehicle";
        }
        public override void BuilderEngine()
        {
            vehicle["engine"] = "100 cc";
        }
        public override void BuilderWheels()
        {
            vehicle["wheels"] = "4";
        }
        public override void BuilderDoors()
        {
            vehicle["doors"]="4";
        }
    }

    #endregion

    /// <summary>
    /// product class
    /// </summary>
    class Vehicle
    {
        private string _vehicleType;
        private Dictionary<string, string> _parts = new Dictionary<string, string>();

        // Constructor
        public Vehicle(string vehicleType)
        {
            this._vehicleType = vehicleType;
        }

        /// <summary>
        ///  Indexer
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string this[string key]
        {
            get { return _parts[key]; }

            set { _parts[key] = value; }
        }


        public void Show()
        {
            Console.WriteLine("\n---------------------------");
            Console.WriteLine("Vehicle Type: {0}", _vehicleType);
            Console.WriteLine(" Frame : {0}", _parts["frame"]);
            Console.WriteLine(" Engine : {0}", _parts["engine"]);
            Console.WriteLine(" #Wheels: {0}", _parts["wheels"]);
            Console.WriteLine(" #Doors : {0}", _parts["doors"]);
        }
    }

   
}

• uml 图