模式說法之——建造者

在軟體系統中，有時候面臨一個“複雜對象”的建立工作，其通常由各個部分的子對象用一定算法構成；由于需求的變化，這個複雜對象的各個部分經常面臨着劇烈的變化，但是将它們組合到一起的算法卻相對穩定。

如何應對種變化呢？如何提供一種“封裝機制”來隔離出“複雜對象的各個部分”的變化，進而保持系統中的“穩定建構算法”不随需求的改變而改變？

将一個複雜對象的建構與其表示相分離，使得同樣的建構過程可以建立不同的表示。

·抽象建造者（Builder）：給出一個抽象接口，以規範産品對象的各個組成成分的建造。這個接口規定要實作複雜對象的哪些部分的建立，并不涉及具體的對象部件的建立。

·具體建造者（Concrete Builder）：實作Builder接口，針對不同的商業邏輯，具體化複雜對象的各部分的建立。 在建造過程完成後，提供産品的執行個體。

·指導者（Director）：調用具體建造者來建立複雜對象的各個部分，在指導者中不涉及具體産品的資訊，隻負責保證對象各部分完整建立或按某種順序建立。

産品（Product）：要建立的複雜對象。

（一）代碼

//複雜的對象

    //各個部分的子對象用一定算法構成

    //各個部分經常面臨着劇烈的變化

    public class Product

    {

        List<string> _list = new List<string>();

        public void Add(string strPart)

        {

            _list.Add(strPart);

        }

        public void Show()

        {

            foreach(string s in _list)

                Console.WriteLine(s);

    }

    //建造者

    public interface IBuilder

        //産品的各個部分

        void BuildPart1();

        void BuildPart2();

        void BuildPartn();

        Product GetProduct();

    //實作建造者

    public class BuilderA : IBuilder

        private Product _product = new Product();

        public void BuildPart1()

            _product.Add("Part 1");

        public void BuildPart2()

            _product.Add("Part 2");

        public void BuildPartn()

            _product.Add("Part n");

        public Product GetProduct()

            return _product;

    //指導者

    public class Director

        public void CreateProduct(IBuilder builder)

            builder.BuildPart1();

            builder.BuildPart2();

            builder.BuildPartn();

（二）測試

[Test]

        public void TestBuilder()

            //建造者

            IBuilder builder = new BuilderA();

            //指導者

            Director director = new Director();

            //指導

            director.CreateProduct(builder);

            //産品

            Product pro = builder.GetProduct();

            //産品内容

            pro.Show();

結果：

Part 1

Part 2

Part n

再舉一個比較容易了解的例子

（一） 産品類

public class Product

        public delegate void DeleDo();

        public List<DeleDo> _list = new List<DeleDo>();

        public void Add(DeleDo i)

            _list.Add(i);

            foreach (DeleDo dd in _list)

            {

                dd();

            }

}

這裡一個完整的産品，它由幾部分構成，因為它的建構相對穩定，但每個部分卻可能發生劇烈變化。因為這個構成如果用别的方法來了解不太好了解，比如：産品類有個字元串的List。這裡用委托實作。可以助于了解：建構部分1,……

（二）建造者接口

public interface IBuilder

        void Part1();

        void Part2();

        void Part3();

        void Part4();

産品建構是相對穩定的，但包括的4部分卻可能發生劇烈變化。

（三）實作構造者1

public class Builder : IBuilder

        Product pro=new Product();

        public void p1() { Console.WriteLine("part 1"); }

        public void p2() { Console.WriteLine("part 2"); }

        public void p3() { Console.WriteLine("part 3"); }

        public void p4() { Console.WriteLine("part 4"); }

        public void Part1()

            pro.Add(p1);

        public void Part2()

            pro.Add(p2);

        public void Part3()

            pro.Add(p3);

        public void Part4()

            pro.Add(p4);

        {           

            return pro;

這裡實作了建造者。每實作一部分的的建構，就代表了整個産品構造完成了一部分。這由産品的Add方法實作。

（四）指揮者

此部分用于建構相對穩定的産品

public class Director

            builder.Part1();

            builder.Part2();

            builder.Part3();

            builder.Part4();

（五）測試

public void TestBuilder()

            IBuilder builder = new Builder();

            Director d = new Director();

            d.CreateProduct(builder);

 其中，建造者用于應對産品各部分劇烈的變化；而指揮者是穩定的。

還得來一個例子,這個例子比較真實,能更好的說明這個建造者模式:

  /*

         * 要建立的對象是個複雜的對象,它由各部分組成.其中每個部分存在變化,而把部分組成整體的算法不變,即可用建造者

         *

         * 建造者抽象

         * 各個建造者

         * 指導者,把部分按固定的算法組成複雜對象,并傳回這個對象

        */

//産品,car

    public class Car

        public void Head(string str)

            Console.WriteLine("head:"+str);

        public void Body(string str)

            Console.WriteLine("body:" + str);

        public void Tail(string str)

            Console.WriteLine("tail:" + str);

        void CreateHead();

        void CreateBody();

        void CreateTail();

        Car GetCar();

    //jeep builder(jeep factory)

    public class JeepBuilder : IBuilder

        Car car = new Car();

        public void CreateHead()

            car.Head("Jeep");

        public void CreateBody()

            car.Body("Jeep");

        public void CreateTail()

            car.Tail("Jeep");

        public Car GetCar()

            return car;

    //指揮者,監督者

        public void CreateCar(IBuilder builder)

            builder.CreateTail();

            builder.CreateBody();

    //部分發生變化,例如現在是truck

    public class TruckBuilder : IBuilder

            car.Head("Truck");

            Console.WriteLine("creating truck head.");

            car.Body("Truck");

            Console.WriteLine("creating truck body.");

            car.Tail("Truck");

            Console.WriteLine("creating truck tail.");

public void Test_4_Builder()

{

    IBuilder builder = new JeepBuilder();

    Director director = new Director();

    director.CreateCar(builder);

    Car car=builder.GetCar();

    builder = new TruckBuilder();

    car = builder.GetCar();

    //維持順序,複雜對象組成算法穩定,部分發生變化.

部落格園大道至簡

http://www.cnblogs.com/jams742003/

轉載請注明：部落格園