4.建造者模式

介绍

在软件系统中，有时候面临一个”复杂对象”的创建工作，其通常由各个部分的子对象用一定算法构成;由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合到一起的算法却相对稳定。

如何应对种变化呢？如何提供一种”封装机制”来隔离出”复杂对象的各个部分”的变化，从而保持系统中的”稳定构建算法”不随需求的改变而改变？

核心要点

“将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示”

例子

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 建造者模式
{
    //指挥创建过程类，建造者模式的指挥类
    class Director
    {
        public void Construct(Builder builder)
        {
            builder.BuilderPartA();
            builder.BuilderPartB();
        }
    }
    //抽象建造者，也可以定义为接口
    abstract class Builder
    {
        public abstract void BuilderPartA();
        public abstract void BuilderPartB();
        public abstract Product GetProduct();
    }
    //具体建造者1
    class ConcreateBuilder1 : Builder
    {
        Product product = new Product();
        public override void BuilderPartA()
        {
            product.Add("PartA");
        }

        public override void BuilderPartB()
        {
            product.Add("PartB");
        }

        public override Product GetProduct()
        {
            return product;
        }
    }
    //具体建造者2
    class ConcreateBuilder2 : Builder
    {
        Product product = new Product();
        public override void BuilderPartA()
        {
            product.Add("PartA");
        }

        public override void BuilderPartB()
        {
            product.Add("PartB");
        }

        public override Product GetProduct()
        {
            return product;
        }
    }
    //产品
    class Product
    {
        ArrayList parts = new ArrayList();
        public void Add(string part)
        {
            parts.Add(part);
        }
        public void Show()
        {
            Console.WriteLine("\n Product Parts------");
            foreach (var part in parts)
            {
                Console.WriteLine(part.ToString());
            }
        }
    }
 }


// 调用方式
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
/*
 *将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
 */
namespace 建造者模式
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建指挥者和建造者
            Director director = new Director();
            Builder builder1 = new ConcreateBuilder1();
            Builder builder2 = new ConcreateBuilder2();

            //指挥者指挥建造者1干活
            director.Construct(builder1);
            Product product1 = builder1.GetProduct();
            product1.Show();

            //指挥者指挥建造者2干活
            director.Construct(builder2);
            Product product2 = builder2.GetProduct();
            product2.Show();

            Console.ReadKey();
        }
    }
}

这种例子生活中很多，比方说，你去麦当劳买东西吃，售货员就是指挥者，做饭的就是建造者，建造者有很多的，可以做不同种类的东西。再比方说，你为公司去电脑城采购电脑，此时老板就是指挥者，具体组装电脑的就是建造者，你只需要告诉参数就完事。