建造者模式

1. 介绍

建造者模式是一种设计模式，用于构建复杂对象的各个部分，而无需指定该对象的具体类。它通过逐步创建对象的各个部分，并利用建造者对象将这些部分组装成最终产品。这种模式特别适用于需要创建复杂对象的场景，尤其是在对象的创建过程涉及多个步骤，或者对象的不同部分可以独立变化时。

主要角色

产品（Product）: 最终构建的复杂对象，包含各种组成部分。
抽象建造者（Builder）: 定义创建产品的步骤和方法，但不负责具体的组合。
具体建造者（Concrete Builder）: 继承自抽象建造者，实现具体步骤，负责实际创建产品的部分。
指挥者（Director）: 管理建造过程，调用建造者的方法以确保产品按顺序构建。
客户端（Client）: 使用指挥者来获取最终产品，无需了解构建过程的细节。

应用场景

复杂对象构建: 构建需要多个步骤的复杂对象时，建造者模式非常适用。
步骤独立性: 每个步骤可能需要不同设置时，建造者模式能有效组织这些步骤。
组件独立变化: 当对象的不同部分可以独立变化时，简化对象的创建过程。
重用构建过程: 在多个地方重复使用对象的创建过程时，封装和复用逻辑。
复杂算法: 构建过程涉及复杂逻辑时，封装在具体建造者中，客户端可以简单获取产品。

优点

分离创建与表示: 提高代码灵活性和可维护性。
增加灵活性: 通过不同的建造者配置不同产品特性。
避免参数爆炸: 使代码清晰易懂。
更好的封装: 客户端专注于最终产品，无需了解创建细节。

缺点

增加复杂性: 引入多个角色可能增加系统复杂性。
多个建造者: 对于每种产品类型，可能需要定义多个具体建造者，增加代码量。

2. 代码案例

// =================== 建造者模式 ===================

using System;

// =================== 产品类（Product） ===================
public class Car
{
    private string engine;      // 发动机类型
    private string transmission; // 变速器类型
    private string wheels;      // 车轮类型
    private string color;       // 颜色
    private bool isSunroof;     // 是否有天窗

    public Car()
    {
        isSunroof = false; // 默认无天窗
    }

    public override string ToString()
    {
        return $"汽车 [发动机={engine}, 变速器={transmission}, 车轮={wheels}, 颜色={color}, 天窗={isSunroof}]";
    }

    // Builder 类用于逐步构建 Car 对象。
    public class Builder
    {
        private Car car;

        public Builder()
        {
            car = new Car();
        }

        public Builder SetEngine(string engine)
        {
            car.engine = engine;
            return this;
        }

        public Builder SetTransmission(string transmission)
        {
            car.transmission = transmission;
            return this;
        }

        public Builder SetWheels(string wheels)
        {
            car.wheels = wheels;
            return this;
        }

        public Builder SetColor(string color)
        {
            car.color = color;
            return this;
        }

        public Builder SetSunroof(bool isSunroof)
        {
            car.isSunroof = isSunroof;
            return this;
        }

        public Car Build()
        {
            return car;
        }
    }
}

// =================== 抽象建造者（Builder） ===================
public abstract class CarBuilder
{
    public abstract CarBuilder BuildEngine();
    public abstract CarBuilder BuildTransmission();
    public abstract CarBuilder BuildWheels();
    public abstract CarBuilder BuildColor();
    public abstract CarBuilder BuildSunroof();
    public abstract Car GetResult();
}

// =================== 具体建造者（Concrete Builder） ===================
public class SportsCarBuilder : CarBuilder
{
    private Car.Builder builder;

    public SportsCarBuilder()
    {
        builder = new Car.Builder();
    }

    public override CarBuilder BuildEngine()
    {
        builder.SetEngine("V8 发动机");
        return this;
    }

    public override CarBuilder BuildTransmission()
    {
        builder.SetTransmission("6速手动");
        return this;
    }

    public override CarBuilder BuildWheels()
    {
        builder.SetWheels("运动轮胎");
        return this;
    }

    public override CarBuilder BuildColor()
    {
        builder.SetColor("红色");
        return this;
    }

    public override CarBuilder BuildSunroof()
    {
        builder.SetSunroof(true);
        return this;
    }

    public override Car GetResult()
    {
        return builder.Build();
    }
}

// =================== 指挥者（Director） ===================
public class CarDirector
{
    private CarBuilder builder;

    public CarDirector(CarBuilder builder)
    {
        this.builder = builder;
    }

    public Car Construct()
    {
        return builder.BuildEngine()
                      .BuildTransmission()
                      .BuildWheels()
                      .BuildColor()
                      .BuildSunroof()
                      .GetResult();
    }
}

// =================== 客户端（Client） ===================
public class Program
{
    public static void Main(string[] args)
    {
        // 创建具体建造者
        CarBuilder builder = new SportsCarBuilder();

        // 创建指挥者并传入建造者
        CarDirector director = new CarDirector(builder);

        // 使用指挥者构建汽车
        Car car = director.Construct();

        // 输出构建的汽车
        Console.WriteLine(car);

        // 直接使用建造者链式调用构建汽车
        Car customCar = builder.BuildEngine()
                                .BuildTransmission()
                                .BuildWheels()
                                .BuildColor()
                                .BuildSunroof()
                                .GetResult();
        Console.WriteLine(customCar);
    }
}