设计模式之 建造者模式 C# 范例

建造者模式（Builder Pattern）是一种创建型设计模式，它通过使用多个简单的对象一步步构建一个复杂的对象。在C#中，建造者模式通常用于分步构建一个复杂的对象，而不需要暴露其内部构建逻辑。

下面是一个C#建造者模式的示例，用于创建一个复杂的Product对象，例如一个Computer对象。

1. 定义产品类（Product）

public class Computer
{
    public string CPU { get; set; }
    public string RAM { get; set; }
    public string Storage { get; set; }
    public string GPU { get; set; }

    public override string ToString()
    {
        return $"Computer [CPU={CPU}, RAM={RAM}, Storage={Storage}, GPU={GPU}]";
    }
}

2. 定义建造者接口（Builder）

public interface IComputerBuilder
{
    void BuildCPU();
    void BuildRAM();
    void BuildStorage();
    void BuildGPU();
    Computer GetComputer();
}

3. 创建具体的建造者（Concrete Builder）

public class GamingComputerBuilder : IComputerBuilder
{
    private Computer _computer;

    public GamingComputerBuilder()
    {
        _computer = new Computer();
    }

    public void BuildCPU()
    {
        _computer.CPU = "Intel Core i9";
    }

    public void BuildRAM()
    {
        _computer.RAM = "32GB DDR4";
    }

    public void BuildStorage()
    {
        _computer.Storage = "1TB SSD";
    }

    public void BuildGPU()
    {
        _computer.GPU = "NVIDIA RTX 3080";
    }

    public Computer GetComputer()
    {
        return _computer;
    }
}

public class OfficeComputerBuilder : IComputerBuilder
{
    private Computer _computer;

    public OfficeComputerBuilder()
    {
        _computer = new Computer();
    }

    public void BuildCPU()
    {
        _computer.CPU = "Intel Core i5";
    }

    public void BuildRAM()
    {
        _computer.RAM = "8GB DDR4";
    }

    public void BuildStorage()
    {
        _computer.Storage = "500GB SSD";
    }

    public void BuildGPU()
    {
        _computer.GPU = "Integrated Graphics";
    }

    public Computer GetComputer()
    {
        return _computer;
    }
}

4. 定义指挥者（Director）

指挥者（Director）负责使用建造者（Builder）构建产品。

public class ComputerDirector
{
    private readonly IComputerBuilder _builder;

    public ComputerDirector(IComputerBuilder builder)
    {
        _builder = builder;
    }

    public Computer Construct()
    {
        _builder.BuildCPU();
        _builder.BuildRAM();
        _builder.BuildStorage();
        _builder.BuildGPU();
        return _builder.GetComputer();
    }
}

5. 使用建造者模式创建产品

public class Program
{
    public static void Main(string[] args)
    {
        // 使用GamingComputerBuilder构建一台游戏电脑
        IComputerBuilder gamingComputerBuilder = new GamingComputerBuilder();
        ComputerDirector director = new ComputerDirector(gamingComputerBuilder);
        Computer gamingComputer = director.Construct();
        Console.WriteLine("Gaming Computer: " + gamingComputer);

        // 使用OfficeComputerBuilder构建一台办公电脑
        IComputerBuilder officeComputerBuilder = new OfficeComputerBuilder();
        director = new ComputerDirector(officeComputerBuilder);
        Computer officeComputer = director.Construct();
        Console.WriteLine("Office Computer: " + officeComputer);
    }
}

输出结果：

Gaming Computer: Computer [CPU=Intel Core i9, RAM=32GB DDR4, Storage=1TB SSD, GPU=NVIDIA RTX 3080]
Office Computer: Computer [CPU=Intel Core i5, RAM=8GB DDR4, Storage=500GB SSD, GPU=Integrated Graphics]

说明

1. 产品类（Product） ：Computer类是最终构建的对象，它具有多个属性。
2. 建造者接口（Builder） ：IComputerBuilder接口定义了构建产品的各个步骤。
3. 具体建造者（Concrete Builder） ：GamingComputerBuilder和OfficeComputerBuilder分别用于构建不同类型的计算机。
4. 指挥者（Director） ：ComputerDirector负责指导建造过程，确保按正确的顺序调用建造步骤。
5. 客户端代码 ：客户端代码（Program类）使用建造者模式来创建具体的计算机对象。

优点

• 分离复杂对象的构建与表示：建造者模式使得对象的构建过程与其表示分离，客户端只需关注如何构建对象，而不必关心构建的具体过程。
• 灵活性：可以通过不同的建造者来创建不同类型的产品。
• 清晰的分步过程：每个步骤都是明确的，这对于构建过程较复杂的对象非常有帮助。

通过这种方式，您可以非常方便地构建具有不同配置的Computer对象，并且可以在不修改客户端代码的情况下修改建造的细节。