建造者模式（Builder Pattern）

建造者模式（Builder Pattern）

建造者模式（Builder Pattern），将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

结构

参与者
Builder
——为创建一个Product对象的各个部件指定抽象接口。
ConcreteBuilder
——实现Builder的接口以构造和装配该产品的各个部件。
——定义并明确它所创建的表示。
Director
——构造一个使用Builder接口的对象。
Product
——表示被构造的复杂对象。 ConcreteBuilder创建该产品的内部表示并定义它的装配过程。

——包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

协作

代码

<span style="font-size:18px;"><span style="font-size:14px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyBuilder
{
    abstract class Builder
    {
        public abstract void BuildPartA();
        public abstract void BuildPartB();
        public abstract Product GetResult();
    }

    class ConcreteBuilder1 : Builder
    {
        private Product product = new Product();

        public override void BuildPartA()
        {
            product.Add("Part A");
        }

        public override void BuildPartB()
        {
            product.Add("Part B");
        }

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

    class ConcreteBuilder2 : Builder
    {
        private Product product = new Product();

        public override void BuildPartA()
        {
            product.Add("Part X");
        }

        public override void BuildPartB()
        {
            product.Add("Part Y");
        }

        public override Product GetResult()
        {
            return product;
        }
    }
}
</span></span>

<span style="font-size:18px;"><span style="font-size:14px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyBuilder
{
    class Director
    {
        public void Construct(Builder builder)
        {
            builder.BuildPartA();
            builder.BuildPartB();
        }
    }
}
</span></span>

<span style="font-size:18px;"><span style="font-size:14px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyBuilder
{
    class Product
    {
        IList<string> parts = new List<string>();

        public void Add(string part)
        {
            parts.Add(part);
        }

        public void Show()
        {
            Console.WriteLine("产品创建:");
            foreach (string part in parts)
            {
                Console.WriteLine(part);
            }
        }
    }
}
</span></span>

<span style="font-size:18px;"><span style="font-size:14px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyBuilder
{
    class Program
    {
        static void Main(string[] args)
        {
            Director director = new Director();
            Builder b1 = new ConcreteBuilder1();
            Builder b2 = new ConcreteBuilder2();

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

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

            Console.ReadKey();
        }
    }
}
</span></span>

实现

通常有一个抽象的Builder类为导向者可能要求创建的每一个构件定义一个操作。这些操作缺省情况下什么都不做。一个ConcreteBuilder类对它有兴趣创建的构件重定义这些操作。

在Builder中缺省的方法为空C++中，生成方法故意不声明为纯虚成员函数，而是把它们定义为空方法，这使客户只重定义他们所感兴趣的操作。

总结

主要是用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复制的变化。

建造者模式的好处就是使得建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要在定义一个具体的建造者就可以了。