C# 建造者模式（Builder Pattern）

建造者模式（Builder Pattern），也被称为生成器模式，是一种对象构建模式，旨在将复杂对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。这种模式特别适用于构建具有多个组成部分的复杂对象，且这些组成部分的创建和组装方式相对独立。

public class BuilderPatternTest
{
    public void Main()
    {
        var director = new Director();//指挥者1
        var director1 = new Director1();//指挥者2
        var desktopBuilder = new DesktopBuilder();//建造者1
        var desktopBuilder2 = new DesktopBuilder2();//建造者2

        //第一台电脑，使用指挥者1，使用建造者1
        var computer1 = director.Construct(desktopBuilder);
        Console.WriteLine(computer1.ToString());

        //第二台电脑，使用指挥者2，使用建造者2
        var computer2 = director1.Construct(desktopBuilder);
        Console.WriteLine(computer2.ToString());

        //第三台电脑，使用指挥者1，使用建造者2
        var computer3 = director.Construct(desktopBuilder2);
        Console.WriteLine(computer3.ToString());

        //第四台电脑，使用建造者1,不使用指挥者
        var computer4 = new DesktopBuilder()
            .SetType("平板电脑")
            .SetRam(256)
            .SetProcessor("i13212")
            .Build();
        Console.WriteLine(computer4.ToString());
    }
}

// 定义产品类
public class Computer
{
    public string Type { get; }
    public bool IsGraphicsCardIncluded { get; }
    public int Ram { get; }
    public string Processor { get; }

    public Computer(string type, bool isGraphicsCardIncluded, int ram, string processor)
    {
        Type = type;
        IsGraphicsCardIncluded = isGraphicsCardIncluded;
        Ram = ram;
        Processor = processor;
    }

    public override string ToString()
    {
        return $"Type: {Type}, Graphics Card: {IsGraphicsCardIncluded}, RAM: {Ram}GB, Processor: {Processor}";
    }
}

// 抽象建造者
// 也可以使用接口实现抽象建造者
// 方法中返回自身，以便链式调用
public abstract class Builder
{
    protected string Type;
    protected bool IsGraphicsCardIncluded;
    protected int Ram;
    protected string Processor;

    public abstract Computer Build();

    public virtual Builder SetType(string type)
    {
        return this;
    }

    public virtual Builder SetGraphicsCard(bool isGraphicsCardIncluded)
    {
        return this;
    }

    public virtual Builder SetRam(int ram)
    {
        return this;
    }

    public virtual Builder SetProcessor(string processor)
    {
        return this;
    }
}

// 具体建造者
public class DesktopBuilder : Builder
{
    public override Computer Build()
    {
        return new Computer(Type, IsGraphicsCardIncluded, Ram, Processor);
    }

    public override DesktopBuilder SetType(string type)
    {
        Type = type;
        return this;
    }

    public override DesktopBuilder SetGraphicsCard(bool isGraphicsCardIncluded)
    {
        IsGraphicsCardIncluded = isGraphicsCardIncluded;
        return this;
    }

    public override DesktopBuilder SetRam(int ram)
    {
        Ram = ram;
        return this;
    }

    public override DesktopBuilder SetProcessor(string processor)
    {
        Processor = processor;
        return this;
    }
}

public class DesktopBuilder2 : Builder
{
    public override Computer Build()
    {
        return new Computer(Type, IsGraphicsCardIncluded, Ram, Processor);
    }

    public override DesktopBuilder2 SetType(string type)
    {
        Type = type;
        return this;
    }

    public override DesktopBuilder2 SetGraphicsCard(bool isGraphicsCardIncluded)
    {
        IsGraphicsCardIncluded = isGraphicsCardIncluded;
        return this;
    }

    public override DesktopBuilder2 SetRam(int ram)
    {
        Ram = ram;
        return this;
    }
}

// 导演类
public class Director
{
    public Computer Construct(Builder builder)
    {
        builder.SetType("台式电脑");
        builder.SetGraphicsCard(true);
        builder.SetRam(16);
        builder.SetProcessor("i7");
        return builder.Build();
    }
}

public class Director1
{
    public Computer Construct(Builder builder)
    {
        builder.SetType("笔记本电脑");
        builder.SetGraphicsCard(true);
        builder.SetRam(128);
        builder.SetProcessor("i1000");
        return builder.Build();
    }
}