设计模式——建造者模式

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

　　建造者模式同样是为了解决对象创建的低耦合而设计的模式，不过它有一些不同，那就是在于创建一系列对象时有序的，不可缺少的。如果用了建造者模式，那么用户只需指定需要建造的类型就可以得到它们，而建造的过程和细节就不需要知道了。

　　怎样运用建造者模式，有以下几个步骤：

1.Product类，既然是建造，那么必须有产品吧，这里定义了一个产品类，它有多个部件。

/// <summary>
/// 产品类
/// </summary>
public class Product
{
    //创建一个包含产品的集合
    readonly IList<string> _parts = new List<string>();

    /// <summary>
    /// 给集合添加产品
    /// </summary>
    /// <param name="part"></param>
    public void Add(string part)
    {
        _parts.Add(part);
    }

    /// <summary>
    /// 创建并展示产品
    /// </summary>
    public void Show()
    {
        foreach (var part in _parts)
        {
            //在这里输出并展示产品
        }
    }
}

2.Builder类，产品有了，要开始建造了，别急，首先需要定义一个规范去有序的创建，Builder是一个抽象类，定义了创建产品的方法和一个得到产品的方法。

/// <summary>
/// 建造抽象类
/// 定义由子类去实现的抽象方法
/// 定义由子类去实现的得到建造完成的产品结果的抽象方法
/// </summary>
public abstract class Builder
{
    public abstract void BuilderA();
    public abstract void BuilderB();
    public abstract Product GetResult();
}

3.ConcreteBuilder类，建造规范有了，那就具体去实现建造的方法了。

class ConcreteBuilder1 : Builder
{
    //创建一个产品对象
    private readonly Product _product = new Product();

    /// <summary>
    /// 给产品进行A组装
    /// </summary>
    public override void BuilderA()
    {
        _product.Add("部件A");
    }

    /// <summary>
    /// 给产品进行B组装
    /// </summary>
    public override void BuilderB()
    {
        _product.Add("部件B");
    }

    /// <summary>
    /// 返回组装完成的产品
    /// </summary>
    /// <returns>产品</returns>
    public override Product GetResult()
    {
        return _product;
    }
}

class ConcreteBuilder2 : Builder
{
    //创建一个产品对象
    private readonly Product _product = new Product();

    /// <summary>
    /// 给产品进行A组装
    /// </summary>
    public override void BuilderA()
    {
        _product.Add("部件X");
    }

    /// <summary>
    /// 给产品进行B组装
    /// </summary>
    public override void BuilderB()
    {
        _product.Add("部件Y");
    }

    /// <summary>
    /// 返回组装完成的产品
    /// </summary>
    /// <returns>产品</returns>
    public override Product GetResult()
    {
        return _product;
    }
}

4.Derector类，建造的方法有了，谁去建造，怎么建造？由指挥者类去建造。

/// <summary>
/// 指挥者类
/// </summary>
public class Diractor
{
    /// <summary>
    /// 指挥创建一耳光完整的对象
    /// 不会遗漏
    /// </summary>
    /// <param name="builder"></param>
    public void Construct(Builder builder)
    {
        builder.BuilderA();
        builder.BuilderB();
    }
}

5.客户端代码，好了，指挥者也有了，建造方法也有了，加入两个产品去建造下吧。

class Program
{
    static void Main(string[] args)
    {
        //创建指挥者对象
        var diractor = new Diractor();
        //创建具体建造者1对象
        Builder builder1=new ConcreteBuilder1();
        //指挥者指挥去创建产品1
        diractor.Construct(builder1);
        //创建完成，产品来接受
        Product product1 = builder1.GetResult();
        //产品1进行展示
        product1.Show();

        //创建具体建造者2对象
        Builder builder2 = new ConcreteBuilder2();
        //指挥者指挥去创建产品2
        diractor.Construct(builder2);
        //创建完成，产品来接受
        Product product2 = builder2.GetResult();
        //产品2进行展示
        product2.Show();
    }
}

　　一个对象可能有多种算法，为了实现单一责任原则，那么算法的实现应该独立于该对象的组成和装配，那么建造者模式就适用于这种状况。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　以上内容部分参考程杰的《大话设计模式》一书