C# 建造者模式（Builder Pattern）

你想学习C[#中的建造者模式](javascript:😉（Builder Pattern），我会从概念、应用场景、代码实现到核心要点，由浅入深地帮你理解这个设计模式。

一、建造者模式是什么？

建造者模式是一种创建型设计模式，核心思想是：将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

简单来说，就像你去咖啡店点一杯定制咖啡：

• 基础构建流程固定（选杯型→加基底→加配料→加奶/糖）；

• 但每一步可以选不同选项（杯型选大杯/中杯、基底选美式/拿铁、配料选焦糖/巧克力）；

• 最终通过统一的“建造者”组装出你想要的咖啡。

适用场景：

• 对象有多个组成部分，且构建步骤固定但每个步骤的实现可灵活调整；

• 避免构造函数参数过多（“伸缩构造函数”反模式）；

• 需要生成不同配置的复杂对象（如：不同配置的电脑、不同规格的订单）。

二、C# 建造者模式的核心角色

1. 产品（Product）

   ：要构建的复杂对象（如：咖啡、电脑）；

2. 抽象建造者（IBuilder）

   ：定义构建产品的所有步骤（接口/抽象类）；

3. 具体建造者（ConcreteBuilder）

   ：实现抽象建造者的步骤，构建具体的产品变体；

4. 指挥者（Director）

   ：控制构建流程（可选，也可直接由客户端调用建造者）。

三、完整代码实现（咖啡定制案例）

下面用“定制咖啡”的例子实现建造者模式，让你直观理解：

1. 产品类（Coffee）

///<summary>
/// 产品：咖啡（复杂对象）
///</summary>
publicclassCoffee
{
// 咖啡属性
publicstring CupSize { get; set; } // 杯型：大杯/中杯/小杯
publicstring BaseType { get; set; } // 基底：美式/拿铁/卡布奇诺
publicstring Topping { get; set; } // 配料：焦糖/巧克力/无
publicstring MilkType { get; set; } // 奶型：全脂/脱脂/无糖奶

// 展示咖啡配置
publicvoidShowCoffeeInfo()
{
        Console.WriteLine($"定制咖啡：{CupSize} | {BaseType} | 配料：{Topping} | 奶型：{MilkType}");
    }
}

2. 抽象建造者（ICoffeeBuilder）

///<summary>
/// 抽象建造者：定义构建咖啡的所有步骤
///</summary>
publicinterfaceICoffeeBuilder
{
voidBuildCupSize(); // 构建杯型
voidBuildBaseType(); // 构建基底
voidBuildTopping(); // 构建配料
voidBuildMilkType(); // 构建奶型
Coffee GetCoffee(); // 获取最终产品
}

3. 具体建造者（两种咖啡变体）

///<summary>
/// 具体建造者1：焦糖拿铁（大杯、全脂奶）
///</summary>
publicclassCaramelLatteBuilder : ICoffeeBuilder
{
private Coffee _coffee = new Coffee();

publicvoidBuildCupSize()
{
        _coffee.CupSize = "大杯";
    }

publicvoidBuildBaseType()
{
        _coffee.BaseType = "拿铁";
    }

publicvoidBuildTopping()
{
        _coffee.Topping = "焦糖";
    }

publicvoidBuildMilkType()
{
        _coffee.MilkType = "全脂奶";
    }

public Coffee GetCoffee()
{
return _coffee;
    }
}

///<summary>
/// 具体建造者2：无糖美式（中杯、无奶）
///</summary>
publicclassSugarFreeAmericanoBuilder : ICoffeeBuilder
{
private Coffee _coffee = new Coffee();

publicvoidBuildCupSize()
{
        _coffee.CupSize = "中杯";
    }

publicvoidBuildBaseType()
{
        _coffee.BaseType = "美式";
    }

publicvoidBuildTopping()
{
        _coffee.Topping = "无";
    }

publicvoidBuildMilkType()
{
        _coffee.MilkType = "无奶";
    }

public Coffee GetCoffee()
{
return _coffee;
    }
}

4. 指挥者（控制构建流程）

///<summary>
/// 指挥者：负责控制构建流程（固定步骤）
///</summary>
publicclassCoffeeDirector
{
// 构建咖啡的统一流程
public Coffee ConstructCoffee(ICoffeeBuilder builder)
{
        builder.BuildCupSize();
        builder.BuildBaseType();
        builder.BuildTopping();
        builder.BuildMilkType();
return builder.GetCoffee();
    }
}

5. 客户端调用（使用建造者模式）

classProgram
{
staticvoidMain(string[] args)
{
// 1. 创建指挥者
var director = new CoffeeDirector();

// 2. 构建焦糖拿铁
        ICoffeeBuilder latteBuilder = new CaramelLatteBuilder();
        Coffee caramelLatte = director.ConstructCoffee(latteBuilder);
        caramelLatte.ShowCoffeeInfo(); // 输出：定制咖啡：大杯 | 拿铁 | 配料：焦糖 | 奶型：全脂奶

// 3. 构建无糖美式
        ICoffeeBuilder americanoBuilder = new SugarFreeAmericanoBuilder();
        Coffee sugarFreeAmericano = director.ConstructCoffee(americanoBuilder);
        sugarFreeAmericano.ShowCoffeeInfo(); // 输出：定制咖啡：中杯 | 美式 | 配料：无 | 奶型：无奶
    }
}

四、简化版建造者（无指挥者，链式调用）

在实际C[#开发中](javascript:😉，更常用链式建造者（无需指挥者），比如构建DTO/实体类，避免参数过多的构造函数：

///<summary>
/// 简化版链式建造者（常用）
///</summary>
publicclassCoffeeBuilder
{
private Coffee _coffee = new Coffee();

// 链式设置杯型
public CoffeeBuilder WithCupSize(string cupSize)
{
        _coffee.CupSize = cupSize;
returnthis;
    }

// 链式设置基底
public CoffeeBuilder WithBaseType(string baseType)
{
        _coffee.BaseType = baseType;
returnthis;
    }

// 链式设置配料
public CoffeeBuilder WithTopping(string topping)
{
        _coffee.Topping = topping;
returnthis;
    }

// 链式设置奶型
public CoffeeBuilder WithMilkType(string milkType)
{
        _coffee.MilkType = milkType;
returnthis;
    }

// 构建最终产品
public Coffee Build()
{
return _coffee;
    }
}

// 客户端调用（链式构建）
classProgram
{
staticvoidMain(string[] args)
{
// 自定义构建一杯咖啡
        Coffee myCoffee = new CoffeeBuilder()
            .WithCupSize("小杯")
            .WithBaseType("卡布奇诺")
            .WithTopping("巧克力")
            .WithMilkType("脱脂奶")
            .Build();

        myCoffee.ShowCoffeeInfo(); // 输出：定制咖啡：小杯 | 卡布奇诺 | 配料：巧克力 | 奶型：脱脂奶
    }
}

总结

1. 核心目的

   ：分离复杂对象的“构建过程”和“最终表示”，让同一构建流程能创建不同产品；

2. 两种实现方式

   ：

• 标准模式（抽象建造者+具体建造者+指挥者）：适合构建流程固定、产品变体多的场景；

• 链式建造者（无指挥者）：C[#中更常用](javascript:😉，适合灵活定制对象属性，避免“伸缩构造函数”；

4. 适用场景

   ：对象属性多、配置灵活，或需要统一构建流程时优先使用。

建造者模式和工厂模式的区别：工厂模式关注“创建整个对象”，建造者模式关注“一步步构建对象的细节”。