面向对象设计模式之Builder生成器模式（创建型）

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

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

可适用性：当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。当构造过程必须允许被构造的对象有不同的表示时。

UML图解：

示例代码：游戏场景中Builder模式的应用

 house.cs文件代码：

public abstract class House
    {

    }

    public abstract class Door
    { 
    
    }
    public abstract class Windows
    {

    }
    public abstract class Floor
    {

    }
    public abstract class Wall
    {

    }

RomainHouse.cs文件代码：

 public class RomainHouse:House
    {

    }
    public class RomainDoor : Door
    { 
    
    }
    public class RomainWindows : Windows
    { 
    
    }
    public class RomainWall : Wall
    { 
    
    }

    public class RomainFloor : Floor
    { 
    
    }

Builder.cs文件代码：

    /// <summary>
    /// 游戏中的房屋生成器（抽象层次）
    /// </summary>
    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();
    }

    /// <summary>
    /// 具体罗马房屋生成器
    /// </summary>
    public class RomainHouseBuilder : Builder
    {

        public override void BuildDoor()
        {
           //TODO:door...
        }

        public override void BuildWall()
        {
            //TODO:wall...
        }

        public override void BuildWindows()
        {
            //TODO:windows...
        }

        public override void BuildFloor()
        {
            //TODO:floor...
        }

        public override void BuildHouseCeiling()
        {
            //TODO:build a house...
        }

        public override House GetHouse()
        {
            return new RomainHouse();
        }
    }

    /// <summary>
    /// 客户程序
    /// </summary>
    public class GameManager
    {
        //构建过程(即算法是不经常变化的)是稳定的...
        public static House CreateHouse(Builder builder)
        {
            builder.BuildDoor();
            builder.BuildDoor();

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

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

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

            builder.BuildHouseCeiling();

            return builder.GetHouse();
        }
    }

    public class App
    {
        public  static void Main()
        {
            /***
             * 当房屋的风格变化时,只需要继承Builder实现其对应的具体风格房屋的生成器即可
             * 而客户代码可以通过配置文件的形式，通过.NET的反射机制调用改变后的具体生成器
             * ***/
            //从配置文件中动态加载具体房屋生成器dll，保证了客户代码的稳定性；即当你的应用程序
            //版本升级时，你只需要将改变的dll给用户，另者再修改一下配置文件即可扩展此程序
            string assemblyName=ConfigurationManager.AppSettings["BuilderAssembly"];
            string builderName=ConfigurationManager.AppSettings["BuilderName"];
            Assembly builderAssembly = Assembly.Load(assemblyName);
            Type builderType = builderAssembly.GetType(builderName);
            Builder builder =(Builder)Activator.CreateInstance(builderType);

            House house = GameManager.CreateHouse(builder);

            //House house=GameManager.CreateHouse(new RomainHouseBuilder());
        }
    }

注：本示例代码是本人学习Webcast C#面向对象设计模式纵横谈系列讲座视频时，跟着李建忠老师一步一步的编写的，在此奉献出来，仅供大家参考