C#面向对象设计模式纵横谈 学习笔记4 Builder 生成器（创建型模式）

这一讲的内容是Builder生成器模式

先看看Builder模式的动机

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

对比一下抽象工厂的动机：在软件系统中，经常面临着"一系列相互依赖的对象"的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种"封装机制"来避免客户程序和这种"多系列具体对象创建工作"的紧耦合。

抽象工厂面对的是一系列相互依赖的对象的创建工作，而Builder模式面对的是一个复杂对象的创建工作，这个复杂对象的创建工作中使用的类型经常面临着剧烈的变化，但是算法相对稳定。

Builder模式的意图：将一个复杂对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

抽象工厂的意图：提供一个接口，让该接口负责创建一系列"相关或者相互依赖的对象"，无需指定它们具体的类。

下面通过Builder模式的代码来表现Builder模式。

首先我们有一个Builder的抽象基类，规定这个Builder产生的各种对象。这个Build可以产生Door、Wall、Window、Floor、HouseCelling等。

public abstract class Builder
{
public abstract void BuildDoor();
public abstract void BuildWall();
public abstract void BuildWindow();
public abstract void BuildFloor();
public abstract void BuildHouseCelling();

public abstract House GetHouse();
}

那么我们知道这个抽象基类是稳定的。

public abstract class Door
{
}

public abstract class Wall
{
}

public abstract class Window
{
}

public abstract class Floor
{
}

public abstract class HouseCelling
{
}

public abstract class House
{
}

这几个类定义了这个房子的几个组成部分，他们也是稳定的。

public class GameManager
{
public static House CreateHouse(Builder builder)
{
builder.BuildDoor();
builder.BuildDoor();

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

builder.BuildWindow();
builder.BuildWindow();

builder.BuildFloor();
builder.BuildHouseCelling();

return builder.GetHouse();
}
}

这是创建一个房子的步骤，这个也是稳定的。

public class RomanHouse : House
{
}

public class RomanDoor : Door
{
}

public class RomanWall : Wall
{
}

public class RomanWindow : Window
{
}

public class RomanFloor : Floor
{
}

public class RomanHouseCelling : HouseCelling
{
}

public class RomanHouseBuilder : Builder
{

public override void BuildDoor()
{
}

public override void BuildWall()
{
}

public override void BuildWindow()
{
}

public override void BuildFloor()
{
}

public override void BuildHouseCelling()
{
}

public override House GetHouse()
{
}
}

那么我们的变化就在这个Builder的派生类RomanBuilder类和具体实现window、wall等类中。我们可以让RomanBuilder类中的各个方法产生不同的Window、Floor，不一定是一样的风格比如BuildWindow可以使用RomanWindow，但BuildDoor产生的是ChineseDoor。

客户端调用

static void Main(string[] args)
{
House house = GameManager.CreateHouse(new RomanHouseBuilder());
}
这个地方可以通过修改代码来产生一个builder，也可以使用反射来产生builder

static void Main(string[] args)
{
string assemblyName = ConfigrationSettings["BuildAssembly"];
string builderName = ConfigrationSettings["BuildClass"];
Assembly assembly = Assembly.Load(assemblyName);
Type t = assembly.GetType(builderName);
Builder builder = Activator.CreateInstance(t);

House house = GameManager.CreateHouse(builder);
}

将Builder模式的GameManager于抽象工厂的BuildGameFacilites对比。

public void BuildGameFacilites()
{
Road road = faciliesFactory.CreateRoad();

Building building = faciliesFactory.CreateBuilding();

Tunnel tunnel = faciliesFactory.CreateTunnel();

Jungle jungle = faciliesFactory.CreateJungle();
}

public static House CreateHouse(Builder builder)
{
builder.BuildDoor();
builder.BuildDoor();

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

builder.BuildWindow();
builder.BuildWindow();

builder.BuildFloor();
builder.BuildHouseCelling();

return builder.GetHouse();
}

在Builder里面，builder创建的对象不一定是同一风格的，他可以是由其他各种类型组成的，但是其他各种类型的个数固定，算法固定，在抽象工厂中，我们是通过一个风格的Factory来创建同一风格的对象，并且，在BuildGameFacilites方法中，他的算法并不是相对稳定的。并且在Builder模式中，是组装一系列的组件生产出一件产品。抽象工厂是生产一系列产品的需要。builder模式可以利用抽象工厂方法生产自己的组件，而抽象工厂方法如果将所有生产的产品组装在一起也就成为了builder模式。那么这就是Builder模式与抽象工厂模式的异同。
Builder 模式的几个要点

Builder 模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。

变化点在哪里，封装哪里—— Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。也就是说CreateHouse方法变动频繁，Builder模式就不是很适用了。

Abstract Factory模式解决“系列对象”的需求变化，Builder模式解决“对象部分”的需求变化。Builder模式通常和Composite模式组合使用。