設計模式-建造者模式（Builder）

簡介：

將一個複雜的對象的構建與它的表示分離，使得同樣的構建過程創建出不同的表示。

結構圖：

優點：

1. 使得創建代碼和表示代碼分離，建造者隱藏了該產品是如何組裝的，所以若需要改變一個產品內部的表示，只需要再定義一個具體的建造者就可以了；
2. 便於控制細節風險。

缺點：

1. 產品必須有共同點，範圍有限制；
2. 若內部變化複雜，會有很多建造者類。

應用場景：

1. 主要用於創建一些複雜的對象，這些對象內部構建間的建造順序通常是穩定的，但內部的構建通常面臨這複雜的變化；
2. 當創建複雜對象的演算法應該獨立於該對象的組成部分以及裝配方式時；
3. 需要生產的產品對象的屬性相互依賴，需要指定其生成順序時。

註意事項：

與工廠模式相比，更加關註與零配件的裝配順序。

示例：

 1.結構類圖的實現

Product類，產品類，由多個部件組成

    /// <summary>
    /// 產品類
    /// </summary>
    public class Product
    {
        List<string> parts = new List<string>();
        /// <summary>
        /// 添加產品部件
        /// </summary>
        /// <param name="part"></param>
        public void AddPart(string part)
        {
            parts.Add(part);
        }
        /// <summary>
        /// 列舉所有產品部件
        /// </summary>
        public void Show()
        {
            Console.WriteLine("產品創建-----------");
            parts.ForEach(x => Console.WriteLine(x));
        }
    }

Builder類，抽象建造者類，確定產品是由兩個部件PartA和PartB組成，並聲明一個得到產品建造後的結果的方法GetResult()

    /// <summary>
    /// 抽象建造者類
    /// </summary>
    public abstract class Builder
    {
        /// <summary>
        /// 部件A
        /// </summary>
        public abstract void BuildPartA();
        /// <summary>
        /// 部件B
        /// </summary>
        public abstract void BuildPartB();
        /// <summary>
        /// 獲取產品
        /// </summary>
        /// <returns>具體產品</returns>
        public abstract Product GetResult();
    }

ConcreteBuilder類，具體的建造者類

    public class ConcreteBuilder1 : Builder
    {
        private Product product = new Product();
        public override void BuildPartA()
        {
            product.AddPart("部件A");
        }

        public override void BuildPartB()
        {
            product.AddPart("部件B");
        }

        public override Product GetResult()
        {
            return product;
        }
    }

    public class ConcreteBuilder2 : Builder
    {
        private Product product = new Product();
        public override void BuildPartA()
        {
            product.AddPart("部件X");
        }

        public override void BuildPartB()
        {
            product.AddPart("部件Y");
        }

        public override Product GetResult()
        {
            return product;
        }
     }

Director類，指揮者類，規範產品部件生成的順序

    /// <summary>
    /// 指揮者類
    /// </summary>
    public class Director
    {
        public void Construct(Builder builder)
        {
            builder.BuildPartA();
            builder.BuildPartB();
        }
    }

客戶端

     Director director = new Director();
     ConcreteBuilder1 builder1 = new ConcreteBuilder1();
     director.Construct(builder1);
     Product p1 = builder1.GetResult();
     p1.Show();

     ConcreteBuilder2 builder2 = new ConcreteBuilder2();
     director.Construct(builder2);
     Product p2 = builder2.GetResult();
     p2.Show();

結果

2.建造者模式之西安美食

去西安必須要吃的就是涼皮，肉夾饃，羊肉泡饃...，這些美食會以套餐的形成展示給我們，不同的套餐就是【Product】，一道道美食就是組成【Product】的部件；不同的組合方式就是【Builder】,廚師【Director】將他們搭配起來。

套餐

    /// <summary>
    /// 套餐
    /// </summary>
    public class Meal
    {
        List<string> parts = new List<string>();
        public void AddPart(string part)
        {
            parts.Add(part);
        }

        public void Show()
        {
            Console.WriteLine("您的套餐齊了：");
            parts.ForEach(x => Console.Write(x + "　"));
            Console.WriteLine("\n**************");
        }
    }

套餐創建的抽象類

    /// <summary>
    /// 創建套餐
    /// </summary>
    public abstract class BuildMeal
    {
        protected Meal meal = new Meal();
        public abstract void BuildePartA();
        public abstract void BuildePartB();
        public abstract void BuildePartC();
        public Meal GetMeal()
        {
            return meal;
        }
    }

具體套餐的創建

    /// <summary>
    /// 經典套餐
    /// </summary>
    public class BuildClassicalMeal : BuildMeal
    {
        public override void BuildePartA()
        {
            meal.AddPart("肉夾饃");
        }

        public override void BuildePartB()
        {
            meal.AddPart("涼皮");
        }

        public override void BuildePartC()
        {
            meal.AddPart("冰峰");
        }
    }
    /// <summary>
    /// 豪華套餐
    /// </summary>
    public class BuildLuxuriousMeal : BuildMeal
    {
        public override void BuildePartA()
        {
            meal.AddPart("羊肉泡饃");
        }

        public override void BuildePartB()
        {
            meal.AddPart("糖蒜");
        }

        public override void BuildePartC()
        {
            meal.AddPart("黑米粥");
        }
    }

廚師裝配

    /// <summary>
    /// 廚師
    /// </summary>
    public class Chef
    {
        /// <summary>
        /// 生成套餐的過程
        /// </summary>
        /// <param name="buildMeal"></param>
        public void GiveMeal(BuildMeal buildMeal)
        {
            buildMeal.BuildePartA();
            buildMeal.BuildePartB();
            buildMeal.BuildePartC();
        }
    }

客戶端

    Chef chef = new Chef();
    BuildClassicalMeal buildClassical = new BuildClassicalMeal();
    chef.GiveMeal(buildClassical);
    Meal classicalMeal = buildClassical.GetMeal();
    classicalMeal.Show();
    
    BuildLuxuriousMeal buildLuxurious = new BuildLuxuriousMeal();
    chef.GiveMeal(buildLuxurious);
    Meal luxuriousMeal = buildLuxurious.GetMeal();
    luxuriousMeal.Show();

結果

請 多多指教~（看過記得到西安去品嘗喲）