【设计模式】1. 构建器模式（Builder Pattern）是一种创建型设计模式

构建器模式（Builder Pattern）是一种创建型设计模式，用于分步骤构建复杂对象，同时允许按照不同的需求生成不同的表示。该模式将对象的构建过程与其表示分离，使得相同的构建过程可以创建不同的对象。

核心思想

构建器模式通过将对象的构造过程抽象化为多个步骤，使得构造过程可以灵活调整，甚至可以动态选择具体的构建器以生成不同的对象。这样可以解决在复杂对象构建时，代码变得冗长、难以维护的问题。

参与者

1. 产品（Product）

   • 要创建的复杂对象。
   • 包含多个部件。
   • 例如：一个汽车、一个用户界面。

2. 构建器接口（Builder）

   • 定义构建产品的步骤。
   • 通常包括添加部件的方法。

3. 具体构建器（Concrete Builder）

   • 实现构建器接口。
   • 负责具体实现如何一步步地构造产品。
   • 它维护一个具体的产品实例。

4. 指导者（Director）

   • 控制构建过程的逻辑和顺序。
   • 知道如何使用构建器来创建产品。

5. 客户代码（Client）

   • 指定需要构建的产品类型，并提供相关的参数。
   • 使用指导者调用构建器完成产品构建。

示例代码（C#）

以下是一个简单的汽车建造器的例子：

// 产品：汽车
class Car
{
    public string Engine { get; set; }
    public string Wheels { get; set; }
    public string Body { get; set; }

    public override string ToString()
    {
        return $"Engine: {Engine}, Wheels: {Wheels}, Body: {Body}";
    }
}

// 构建器接口
interface ICarBuilder
{
    void BuildEngine();
    void BuildWheels();
    void BuildBody();
    Car GetCar();
}

// 具体构建器
class SportsCarBuilder : ICarBuilder
{
    private Car _car = new Car();

    public void BuildEngine()
    {
        _car.Engine = "V8 Engine";
    }

    public void BuildWheels()
    {
        _car.Wheels = "Sport Wheels";
    }

    public void BuildBody()
    {
        _car.Body = "Sport Body";
    }

    public Car GetCar()
    {
        return _car;
    }
}

// 指导者
class Director
{
    private ICarBuilder _builder;

    public Director(ICarBuilder builder)
    {
        _builder = builder;
    }

    public void Construct()
    {
        _builder.BuildEngine();
        _builder.BuildWheels();
        _builder.BuildBody();
    }
}

// 客户代码
class Program
{
    static void Main(string[] args)
    {
        // 使用具体构建器
        ICarBuilder builder = new SportsCarBuilder();
        Director director = new Director(builder);

        // 指导者负责构建产品
        director.Construct();

        // 获取构建好的产品
        Car car = builder.GetCar();
        Console.WriteLine(car);
    }
}

优点

1. 易于扩展：可以通过添加新的具体构建器支持更多产品表示。
2. 分离复杂对象的创建和表示：更清晰地组织代码。
3. 灵活性：可以根据需要动态调整构造步骤。

缺点

1. 增加代码复杂性：需要引入多个类和接口。
2. 适用场景有限：主要适用于需要分步骤构建的复杂对象。

使用场景

1. 构建一个由多个组件组成的复杂对象，例如生成器游戏关卡、配置文件生成等。
2. 需要生成多个不同表示的对象，但构造过程相似。
3. 希望控制对象的构造步骤，而不直接依赖产品的细节。

构建器模式的设计理念在于简化复杂对象的构建，并提供灵活性以适应变化。

个人经验：

1. 可以和类内类Builder和链式调用一起用，用Builder. SetEngine(x,x),SetWheel(),build() 链式调用构建。

public class Product
{
    // 私有构造函数，防止直接实例化
    private Product() { }
    
    // 产品的属性
    public Type1 Property1 { get; private set; }
    public Type2 Property2 { get; private set; }
    public Type3 Property3 { get; private set; }

    // Builder类
    public class Builder
    {
        private Product _product = new Product();

        // 链式方法，每个都返回Builder实例
        public Builder WithProperty1(Type1 value)
        {
            _product.Property1 = value;
            return this;
        }

        public Builder WithProperty2(Type2 value)
        {
            _product.Property2 = value;
            return this;
        }

        public Builder WithProperty3(Type3 value)
        {
            _product.Property3 = value;
            return this;
        }

        // 最终构建方法
        public Product Build()
        {
            // 可以在这里添加参数验证
            return _product;
        }
    }
}

核心要点：

外部类私有构造函数
内部Builder类
链式方法返回Builder本身
Build()方法返回最终产品

调用方式

var product = new Product.Builder()
    .WithProperty1(value1)
    .WithProperty2(value2)
    .WithProperty3(value3)
    .Build();