C#设计模式13——建造者模式的写法

1. 什么是建造者模式？

建造者模式是一种创建型设计模式，它通过将一个复杂的对象分解为多个简单的对象并按照一定的顺序进行组装而创建出一个复杂的对象。这样可以使得构造过程更加灵活，同时也可以隐藏创建过程的复杂性。

2. 建造者模式的使用场景？

建造者模式适用于以下场景：

(1) 当需要创建的对象非常复杂或者包含很多组成部分时；

(2) 当需要创建的对象的构建顺序和方式很重要，不同的构建顺序和方式会产生不同的对象；

(3) 当需要创建的对象需要根据不同的参数来创建时；

(4) 当需要避免创建过程中出现重叠构造方法时。

3. 建造者模式有哪些角色？

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

(1) 抽象建造者（Builder）：定义一个抽象接口，用来规范产品的组建；

(2) 具体建造者（ConcreteBuilder）：实现抽象建造者接口，用来构建和装配各个部件；

(3) 产品（Product）：具体的产品，由多个部件组成；

(4) 指挥者（Director）：负责安排具体建造者的构建顺序，并指导具体建造者构建和装配部件。

4. 建造者模式的优点是什么？

建造者模式的优点如下：

(1) 可以隐藏对象的创建过程，使得构造过程更加灵活，同时也可以避免创建对象时过度复杂和困难。

(2) 可以使用不同的构造方法来创建不同的产品，可以满足不同的需求。

(3) 可以将对象的组装过程逐步实现，使得更好的控制对象的创建过程。

(4) 使得客户端代码与具体创建过程分离，使得系统更加易于维护和升级。

5. 建造者模式的缺点是什么？

建造者模式的缺点如下：

(1) 由于需要创建多个类，因此增加了系统的复杂度。

(2) 创建过程的灵活性和控制性也可能会导致系统的过度设计和变得难以维护。

(3) 相对于其他创建型模式，建造者模式的代码量较大，因此可能增加开发成本。

下面是一个使用建造者模式创建电脑的 C# 代码示例：

//产品类-电脑
public class Computer
{
    public string CPU { get; set; }
    public string GPU { get; set; }
    public string Memory { get; set; }
    public string HardDisk { get; set; }

    public void Display()
    {
        Console.WriteLine($"CPU: {CPU}\nGPU: {GPU}\nMemory: {Memory}\nHardDisk: {HardDisk}\n");
    }
}

//抽象建造器类
public abstract class ComputerBuilder
{
    protected Computer computer = new Computer();

    public abstract void BuildCPU();
    public abstract void BuildGPU();
    public abstract void BuildMemory();
    public abstract void BuildHardDisk();

    public Computer GetResult()
    {
        return computer;
    }
}

//建造器类1-游戏电脑
public class GamingComputerBuilder : ComputerBuilder
{
    public override void BuildCPU()
    {
        computer.CPU = "Intel i7-10700K";
    }

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

    public override void BuildMemory()
    {
        computer.Memory = "32GB DDR4";
    }

    public override void BuildHardDisk()
    {
        computer.HardDisk = "2TB SSD + 4TB HDD";
    }
}

//建造器类2-办公电脑
public class OfficeComputerBuilder : ComputerBuilder
{
    public override void BuildCPU()
    {
        computer.CPU = "Intel i5-10400";
    }

    public override void BuildGPU()
    {
        computer.GPU = "Intel UHD Graphics 630";
    }

    public override void BuildMemory()
    {
        computer.Memory = "16GB DDR4";
    }

    public override void BuildHardDisk()
    {
        computer.HardDisk = "512GB NVMe SSD";
    }
}

//指挥官类
public class Director
{
    public void ConstructComputer(ComputerBuilder builder)
    {
        builder.BuildCPU();
        builder.BuildGPU();
        builder.BuildMemory();
        builder.BuildHardDisk();
    }
}

//客户端调用
class Client
{
    static void Main(string[] args)
    {
        Director director = new Director();
        ComputerBuilder gamingBuilder = new GamingComputerBuilder();
        ComputerBuilder officeBuilder = new OfficeComputerBuilder();

        director.ConstructComputer(gamingBuilder);
        Computer gamingComputer = gamingBuilder.GetResult();
        Console.WriteLine("游戏电脑配置如下：");
        gamingComputer.Display();

        director.ConstructComputer(officeBuilder);
        Computer officeComputer = officeBuilder.GetResult();
        Console.WriteLine("办公电脑配置如下：");
        officeComputer.Display();

        Console.ReadLine();
    }
}

在这个示例中，我们定义了一个产品类——电脑类，具有 CPU、GPU、内存、硬盘等属性。

同时我们定义了一个抽象建造者类——ComputerBuilder，其中包含了构建电脑的方法。

然后我们定义了两个具体建造者类——GamingComputerBuilder和OfficeComputerBuilder，用来构建不同类型的电脑。

最后，我们定义了一个指挥官类——Director，用来负责调用建造者类的构建方法，按照一定的顺序来构建电脑。在主函数中，我们实现了客户端代码，实例化了不同的建造者类和指挥官类，然后调用ConstructComputer方法来构建电脑。

输出结果如下：

```
游戏电脑配置如下：
CPU: Intel i7-10700K
GPU: NVIDIA RTX 3080
Memory: 32GB DDR4
HardDisk: 2TB SSD + 4TB HDD

办公电脑配置如下：
CPU: Intel i5-10400
GPU: Intel UHD Graphics 630
Memory: 16GB DDR4
HardDisk: 512GB NVMe SSD
``` 

可以看出，我们成功地创建了不同配置的电脑。