建造者模式

亦称：构造者、生成器、Builder

建造者是一种创建型设计模式， 使你能够分步骤创建复杂对象。 该模式允许你使用相同的创建代码生成不同类型和形式的对象。

💡 适合应用场景

当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，可以考虑使用建造者模式。
特别是当你需要创建一个可能有许多配置选项的对象时， 该模式会特别有用。比如.NETCore的IHost就是通过一个个的配置对象构建而成。如下：

public class Program
{
    public static void Main(string[] args)
    {
        IHostBuilder hostBuilder = Host
            .CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.ConfigureServices(services =>
                {
                    services.AddControllers();
                });
                webBuilder.Configure(app =>
                {
                    app.UseRouting();
                    app.UseAuthorization();
                    app.UseEndpoints(endpoints =>
                    {
                        endpoints.MapControllers();
                    });
                });
            });
        IHost host = hostBuilder.Build();
        host.Run();
    }
}

🖇 结构

# 代码示例

实现简易Sql构建

public interface ISql
{
    string ConnectionString { get; }
    bool IsUseMonitor { get; }
    void Insert();
}
public enum DbType
{
    MySql,
    SqlServer
}
public class SqlBuilder
{
    private string _connectionString;
    private DbType _dbType;
    private bool _isUseMonitor;
    public SqlBuilder() { }
    public SqlBuilder UseConnectionString(DbType dbType, string connectionString)
    {
        _dbType = dbType;
        _connectionString = connectionString;
        return this;
    }
    public SqlBuilder UseMonitor(bool isUseMonitor)
    {
        _isUseMonitor = isUseMonitor;
        return this;
    }
    public ISql Build()
    {
        Type type = null;
        switch (_dbType)
        {
            case DbType.MySql:
                type = typeof(MySql);
                break;
            default:
                throw new NotImplementedException("未实现！");
        }
        ISql sql = Activator.CreateInstance(type, new object[] { _connectionString, _isUseMonitor }) as ISql;
        return sql;
    }
}
public class MySql : ISql
{
    public string ConnectionString { get; protected set; }
    public bool IsUseMonitor { get; protected set; }
    public MySql(string connectionString, bool isUseMonitor)
    {
        ConnectionString = connectionString;
        IsUseMonitor = isUseMonitor;
    }
    public void Insert()
    {
        if (IsUseMonitor)
        {
            Console.WriteLine("开启了监视！");
        }
        Console.WriteLine(DbType.MySql.ToString() + "，插入了一条数据！");
    }
}
public class Program
{
    public static void Main(string[] args)
    {
        // 使用
        var sql = new SqlBuilder()
            .UseConnectionString(DbType.MySql, "192.168.0.1")
            .UseMonitor(true)
            .Build();
        sql.Insert();
    }
}

开启了监视！
MySql，插入了一条数据！

传统模式

// Builder 接口指定了创建 Product 对象不同部分的方法。
public interface IBuilder
{
    void BuildPartA();
    void BuildPartB();
    void BuildPartC();
}

// Concrete Builder 类遵循 Builder 接口并提供构建步骤的特定实现。
// 您的程序可能有几种不同的构建器，实现方式不同。
public class ConcreteBuilder : IBuilder
{
    private Product _product = new Product();
    // 一个新的构建器实例应该包含一个空白产品对象，用于进一步的组装。
    public ConcreteBuilder()
    {
        this.Reset();
    }
    public void Reset()
    {
        this._product = new Product();
    }
    // 所有生产步骤都使用相同的产品实例。
    public void BuildPartA()
    {
        this._product.Add("PartA1");
    }
    public void BuildPartB()
    {
        this._product.Add("PartB1");
    }
    public void BuildPartC()
    {
        this._product.Add("PartC1");
    }
    // Concrete Builders 应该提供他们自己的方法来检索结果。 
    // 这是因为不同类型的构建者可能会创建完全不同的产品，它们不遵循相同的界面。 
    // 因此，此类方法不能在基本 Builder 接口中声明（至少在静态类型的编程语言中）。
    //
    // 通常，在将最终结果返回给客户端后，构建器实例应该准备好开始生产另一个产品。 
    // 这就是为什么通常在 `GetProduct` 方法体的末尾调用 reset 方法的原因。 
    // 但是，此行为不是强制性的，您可以让构建器在处理先前的结果之前等待来自客户端代码的显式重置调用。
    public Product GetProduct()
    {
        Product result = this._product;
        this.Reset();
        return result;
    }
}

// 仅当您的产品非常复杂且需要大量配置时，才有意义使用 Builder 模式。
//
// 与其他创造模式不同，不同的混凝土建造者可以生产不相关的产品。
// 换句话说，不同构建器的结果可能并不总是遵循相同的界面。
public class Product
{
    private List<object> _parts = new List<object>();
    public void Add(string part)
    {
        this._parts.Add(part);
    }
    public string ListParts()
    {
        string str = string.Empty;
        for (int i = 0; i < this._parts.Count; i++)
        {
            str += this._parts[i] + ", ";
        }
        // 删除最后一个",c"
        str = str.Remove(str.Length - 2);
        return "Product parts: " + str + "\n";
    }
}

// Director 仅负责按特定顺序执行构建步骤。
// 在根据特定订单或配置生产产品时很有帮助。
// 严格来说，Director 类是可选的，因为客户端可以直接控制构建器。
public class Director
{
    private IBuilder _builder;
    public IBuilder Builder
    {
        set { _builder = value; }
    }
    // Director 可以使用相同的构建步骤构建多个产品变体。
    public void BuildMinimalViableProduct()
    {
        this._builder.BuildPartA();
    }
    public void BuildFullFeaturedProduct()
    {
        this._builder.BuildPartA();
        this._builder.BuildPartB();
        this._builder.BuildPartC();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 客户端代码创建一个构建器对象，将其传递给主管，然后启动构建过程。
        // 最终结果是从构建器对象中检索的。
        var director = new Director();
        var builder = new ConcreteBuilder();
        director.Builder = builder;
        Console.WriteLine("Standard basic product:");
        director.BuildMinimalViableProduct();
        Console.WriteLine(builder.GetProduct().ListParts());
        Console.WriteLine("Standard full featured product:");
        director.BuildFullFeaturedProduct();
        Console.WriteLine(builder.GetProduct().ListParts());
        // 请记住，Builder 模式可以在没有 Director 类的情况下使用。
        Console.WriteLine("Custom product:");
        builder.BuildPartA();
        builder.BuildPartC();
        Console.Write(builder.GetProduct().ListParts());
    }
}

最终执行结果：

Standard basic product:
Product parts: PartA1
Standard full featured product:
Product parts: PartA1, PartB1, PartC1
Custom product:
Product parts: PartA1, PartC1