创建型模式：Builder 建造者模式-CSDN博客

创建型模式：Builder 建造者模式

１、Builder模式的缘起
１）假设创建游戏中的一个房屋House设施，该房屋的构建由几个部分组成，且各个部分要富于变化。
２）如果使用最直观的设计方法，每一个房屋部分的变化，都将导致房屋构建的重新修正......

２、动机（Motivation）
１）在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂的对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
２）如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中“稳定构建算法”不随着需求改变而改变？
３）把变动的部分隔离出来，与相对隐定的部分分开。

３、意图
      将一个复杂对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
                                                                                   ——《设计模式》GoF
    分析：
      同样的构建过程：相对稳定的算法
      不同的表示：复杂对象的各个部分的变化

４、例子：创建游戏中的一个房屋House
public abstract class House
{
}

public abstract class Door
{
}
public abstract class Wall
{
}
public abstract class Windows
{
}
public abstract class Floor
{
}
public abstract class HouseCeiling
{
}

//Builder生成器
public abstract class Builder
{
//复杂对像的子部分
public abstract void BuildDoor();//门
public abstract void BuildWall();//墙
public abstract void BuildWindows();//窗
public abstract void BuildFloor();//地板
public abstract void BuildHouseCeiling();//天花板

//最后得到复杂对像
public abstract House GetHouse();
}

// 另一个文件
public class GameManager
{
public static House CreateHouse(Builder builder)
{
    //构建房屋的过程是固定的，因此这个部分是稳定的
    builder.BuildDoor();
    builder.BuildDoor();

    builder.BuildWall();
    builder.BuildWall();
    builder.BuildWall();
    builder.BuildWall();

    builder.BuildWindows();
    builder.BuildWindows();

    builder.BuildFloor();
    builder.BuildHouseCeiling();

    return builder.GetHouse();
}
}

//另一文件:不同风格的房子
public class RomanHouse : House
{
}

public class RomanDoor : Door
{
}
public class RomanWall : Wall
{
}
public class RomanWindows : Windows
{
}
public class RomanFloor : Floor
{
}
public class RomanHouseCeiling : HouseCeiling
{
}

public class RomainHouseBuilder : Builder
{
//复杂对像的子部分
public override void BuildDoor()
{
}
public override void BuildWall()
{
}
public override void BuildWindows()
{
}
public override void BuildFloor()
{
}
public override void BuildHouseCeiling()
{
}

//最后得到复杂对像
public override House GetHouse()
{
}
}

//客户程序
class App
{
public static void Main()
{
    // 通过动态反射的机制得到对象,符合开放封闭原则
    //程序集的名字
    string assemblyName = ConfigurationSettings["BuilderAssebmly"];
    //生成器的名字
    string builderName = ConfigurationSettings["BuilderClass"];

    Assembly assembly = Assembly.Load(assemblyName);
    Type t = assembly.GetType("builderName");
    Builder builder = Activator.CreateInstance(t);

    House house = GameManager.CreateHouse(builder) ;
}
}
        需要不同风格的房屋，我们不需要修改代码，只需要扩展代码，开放封闭原则对扩展开放，对修改封闭，这里我们的扩展是增加一个类，继承抽像类House和抽像类Builder。

５、Builder模式的几个要点
１）Builder模式主要用于“分布骤构建一个复杂的对象”。在这其中“分布骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。
２）变化点在哪里，封装哪里——Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。
３）Abstract Factory模式模式解决“系列对象”的需求变化，Builder模式解决“对象部分”的需求变化。Builder模式通常和Composite模式组合使用。