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 模式的几个要点

1. Builder 模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。
2. 变化点在哪里，封装哪里—— Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。也就是说CreateHouse方法变动频繁，Builder模式就不是很适用了。
3. Abstract Factory模式解决“系列对象”的需求变化，Builder模式解决“对象部分”的需求变化。Builder模式通常和Composite模式组合使用。