建造者模式是一种创建型设计模式，它允许你逐步构建复杂对象。该模式的主要目的是将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式通常包含以下几个角色：

1. 产品（Product）：这是最终要构建的复杂对象。它通常包含多个部分或属性。

2. 建造者（Builder）：这是一个抽象接口，定义了构建产品的各个步骤。它通常包含多个方法，每个方法负责构建产品的一个部分。

3. 具体建造者（Concrete Builder）：这是建造者接口的具体实现，负责实际构建产品的各个部分。它会持有产品的实例，并在构建过程中逐步填充产品的属性。

4. 指挥者（Director）：这是负责控制构建过程的类。它使用建造者接口来逐步构建产品，但并不直接创建产品。

5. 客户端（Client）：客户端代码通常会创建一个指挥者对象，并使用它来构建产品。客户端可以选择不同的具体建造者来创建不同的产品表示。

C# 实现建造者模式的演示代码

下面是一个简单的C#示例，演示如何使用建造者模式来构建一个复杂的“电脑”对象。

csharp

using System;
using System.Collections.Generic;

// 产品类：电脑
class Computer
{
    private string _computerType;
    private Dictionary<string, string> _parts = new Dictionary<string, string>();

    public Computer(string computerType)
    {
        this._computerType = computerType;
    }

    // 添加部件
    public void AddPart(string partName, string partValue)
    {
        _parts[partName] = partValue;
    }

    // 显示电脑配置
    public void Show()
    {
        Console.WriteLine("\n---------------------------");
        Console.WriteLine("Computer Type: {0}", _computerType);
        Console.WriteLine(" Motherboard : {0}", _parts["motherboard"]);
        Console.WriteLine(" CPU : {0}", _parts["cpu"]);
        Console.WriteLine(" GPU : {0}", _parts["gpu"]);
        Console.WriteLine(" RAM : {0}", _parts["ram"]);
        Console.WriteLine(" Storage : {0}", _parts["storage"]);
    }
}

// 建造者抽象类
abstract class ComputerBuilder
{
    protected Computer _computer;

    public Computer Computer
    {
        get { return _computer; }
    }

    // 构建电脑的各个部分
    public abstract void BuildMotherboard();
    public abstract void BuildCPU();
    public abstract void BuildGPU();
    public abstract void BuildRAM();
    public abstract void BuildStorage();
}

// 具体建造者：游戏电脑
class GamingComputerBuilder : ComputerBuilder
{
    public GamingComputerBuilder()
    {
        _computer = new Computer("Gaming Computer");
    }

    public override void BuildMotherboard()
    {
        _computer.AddPart("motherboard", "ASUS ROG Maximus XII");
    }

    public override void BuildCPU()
    {
        _computer.AddPart("cpu", "Intel Core i9-10900K");
    }

    public override void BuildGPU()
    {
        _computer.AddPart("gpu", "NVIDIA GeForce RTX 3080");
    }

    public override void BuildRAM()
    {
        _computer.AddPart("ram", "32GB DDR4 3200MHz");
    }

    public override void BuildStorage()
    {
        _computer.AddPart("storage", "1TB NVMe SSD");
    }
}

// 具体建造者：办公电脑
class OfficeComputerBuilder : ComputerBuilder
{
    public OfficeComputerBuilder()
    {
        _computer = new Computer("Office Computer");
    }

    public override void BuildMotherboard()
    {
        _computer.AddPart("motherboard", "ASUS Prime B460M-A");
    }

    public override void BuildCPU()
    {
        _computer.AddPart("cpu", "Intel Core i5-10400");
    }

    public override void BuildGPU()
    {
        _computer.AddPart("gpu", "Integrated Intel UHD Graphics 630");
    }

    public override void BuildRAM()
    {
        _computer.AddPart("ram", "16GB DDR4 2666MHz");
    }

    public override void BuildStorage()
    {
        _computer.AddPart("storage", "512GB SATA SSD");
    }
}

// 指挥者类
class ComputerDirector
{
    public void Build(ComputerBuilder computerBuilder)
    {
        computerBuilder.BuildMotherboard();
        computerBuilder.BuildCPU();
        computerBuilder.BuildGPU();
        computerBuilder.BuildRAM();
        computerBuilder.BuildStorage();
    }
}

// 客户端代码
class Program
{
    static void Main(string[] args)
    {
        // 创建指挥者
        ComputerDirector director = new ComputerDirector();

        // 创建游戏电脑
        ComputerBuilder gamingBuilder = new GamingComputerBuilder();
        director.Build(gamingBuilder);
        Computer gamingComputer = gamingBuilder.Computer;
        gamingComputer.Show();

        // 创建办公电脑
        ComputerBuilder officeBuilder = new OfficeComputerBuilder();
        director.Build(officeBuilder);
        Computer officeComputer = officeBuilder.Computer;
        officeComputer.Show();
    }
}

代码说明

1. 产品类（Computer）：这是我们要构建的复杂对象。它包含多个部件（如主板、CPU、GPU等），并提供了一个Show方法来显示电脑的配置。

2. 建造者抽象类（ComputerBuilder）：这是一个抽象类，定义了构建电脑的各个步骤（如构建主板、CPU等）。每个具体建造者都需要实现这些步骤。

3. 具体建造者（GamingComputerBuilder 和 OfficeComputerBuilder）：这两个类分别实现了ComputerBuilder接口，负责构建不同类型的电脑（游戏电脑和办公电脑）。每个具体建造者在构建过程中会设置不同的部件。

4. 指挥者类（ComputerDirector）：这个类负责控制构建过程。它使用一个建造者对象来逐步构建电脑。指挥者并不知道具体建造者的细节，它只是调用建造者的方法来构建产品。

5. 客户端代码（Program）：客户端代码创建了一个指挥者对象，并使用它来构建不同类型的电脑。客户端可以选择不同的具体建造者来创建不同的产品表示。

运行结果

当你运行这个程序时，输出将显示两种不同类型的电脑配置：

---------------------------
Computer Type: Gaming Computer
 Motherboard : ASUS ROG Maximus XII
 CPU : Intel Core i9-10900K
 GPU : NVIDIA GeForce RTX 3080
 RAM : 32GB DDR4 3200MHz
 Storage : 1TB NVMe SSD

---------------------------
Computer Type: Office Computer
 Motherboard : ASUS Prime B460M-A
 CPU : Intel Core i5-10400
 GPU : Integrated Intel UHD Graphics 630
 RAM : 16GB DDR4 2666MHz
 Storage : 512GB SATA SSD

总结

建造者模式通过将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。这种模式特别适用于构建复杂对象，尤其是当对象的构建过程需要多个步骤时。通过使用建造者模式，你可以更灵活地控制对象的构建过程，并且可以轻松地扩展系统以支持新的产品类型。