建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

我们假设一个快餐店的商业案例，其中，一个典型的套餐可以是一个汉堡（Burger）和一杯冷饮（Cold drink）。汉堡（Burger）可以是素食汉堡（Veg Burger）或鸡肉汉堡（Chicken Burger），它们是包在纸盒中。冷饮（Cold drink）可以是可口可乐（coke）或百事可乐（pepsi），它们是装在瓶子中。

   #region 基本接口 
    interface Item
    {
        float price();
        string name();
        Packing packing();
    }
    //包裹
    interface Packing
    {
        string pack();
    }
    #endregion

   #region 包裹类
    class Wapper : Packing
    {
        public string pack()
        {
            return "wapper";
        }
    }
    class Bottle:Packing
    {
        public string pack()
        {
            return "bottle";
        }
    }
    #endregion

   #region 大的抽象类
    abstract class Burger : Item
    {
        public abstract string name();

        public Packing packing()
        {
            return new Wapper();
        }

        public abstract float price();
    }
    abstract class ColdDrink : Item
    {
        public abstract string name();

        public Packing packing()
        {
            return new Bottle();
        }

        public abstract float price();
    }
    #endregion

 #region 扩展的具体类
    class VegBurger : Burger
    {
        public override string name()
        {
            return "蔬菜汉堡";
        }

        public override float price()
        {
            return 8.0f;
        }
    }
    class ChickenBurger: Burger
    {
        public override string name()
        {
            return "麦辣鸡腿堡";
        }

        public override float price()
        {
            return 18.0f;
        }
    }
    class Coke : ColdDrink
    {
        public override string name()
        {
            return "可口可乐";
        }

        public override float price()
        {
            return 6.0f;
        }
    }
    class Pepsi : ColdDrink
    {
        public override string name()
        {
            return "百事可乐";
        }

        public override float price()
        {
            return 5.0f;
        }
    }
    #endregion

 #region 点餐类
    class Meal
    {
        private List<Item> _itemList = new List<Item>();
        public void Add(Item item)
        {
            _itemList.Add(item);
        }
        public void Remove(Item item)
        {
            _itemList.Remove(item);
        }
        public void ShowMeal()
        {
            foreach (Item item in _itemList)
            {
                Console.WriteLine("name:{0},price{1},package:{2}",item.name(), item.price(), item.packing().pack());
            }
        }
    }
    #endregion

 static void Main(string[] args)
        {
            Meal meal = new Meal();
            meal.Add(new ChickenBurger());
            meal.Add(new Pepsi());
            meal.ShowMeal();
            Console.ReadKey();
        }

建造者模式就是可以一个个堆，重点是都实现最基本的接口，然后在调用建造者的类的时候，通过这个基本接口调用实际类的对象，将入列表中等待使用，完成建造。