【设计模式】1. 构建器模式(Builder Pattern)是一种创建型设计模式

发布于:2024-11-29 ⋅ 阅读:(27) ⋅ 点赞:(0)

构建器模式(Builder Pattern)是一种创建型设计模式,用于分步骤构建复杂对象,同时允许按照不同的需求生成不同的表示。该模式将对象的构建过程与其表示分离,使得相同的构建过程可以创建不同的对象。


核心思想

构建器模式通过将对象的构造过程抽象化为多个步骤,使得构造过程可以灵活调整,甚至可以动态选择具体的构建器以生成不同的对象。这样可以解决在复杂对象构建时,代码变得冗长、难以维护的问题。


参与者

  1. 产品(Product)

    • 要创建的复杂对象。
    • 包含多个部件。
    • 例如:一个汽车、一个用户界面。
  2. 构建器接口(Builder)

    • 定义构建产品的步骤。
    • 通常包括添加部件的方法。
  3. 具体构建器(Concrete Builder)

    • 实现构建器接口。
    • 负责具体实现如何一步步地构造产品。
    • 它维护一个具体的产品实例。
  4. 指导者(Director)

    • 控制构建过程的逻辑和顺序。
    • 知道如何使用构建器来创建产品。
  5. 客户代码(Client)

    • 指定需要构建的产品类型,并提供相关的参数。
    • 使用指导者调用构建器完成产品构建。

示例代码(C#)

以下是一个简单的汽车建造器的例子:

// 产品:汽车
class Car
{
    public string Engine { get; set; }
    public string Wheels { get; set; }
    public string Body { get; set; }

    public override string ToString()
    {
        return $"Engine: {Engine}, Wheels: {Wheels}, Body: {Body}";
    }
}

// 构建器接口
interface ICarBuilder
{
    void BuildEngine();
    void BuildWheels();
    void BuildBody();
    Car GetCar();
}

// 具体构建器
class SportsCarBuilder : ICarBuilder
{
    private Car _car = new Car();

    public void BuildEngine()
    {
        _car.Engine = "V8 Engine";
    }

    public void BuildWheels()
    {
        _car.Wheels = "Sport Wheels";
    }

    public void BuildBody()
    {
        _car.Body = "Sport Body";
    }

    public Car GetCar()
    {
        return _car;
    }
}

// 指导者
class Director
{
    private ICarBuilder _builder;

    public Director(ICarBuilder builder)
    {
        _builder = builder;
    }

    public void Construct()
    {
        _builder.BuildEngine();
        _builder.BuildWheels();
        _builder.BuildBody();
    }
}

// 客户代码
class Program
{
    static void Main(string[] args)
    {
        // 使用具体构建器
        ICarBuilder builder = new SportsCarBuilder();
        Director director = new Director(builder);

        // 指导者负责构建产品
        director.Construct();

        // 获取构建好的产品
        Car car = builder.GetCar();
        Console.WriteLine(car);
    }
}

优点

  1. 易于扩展:可以通过添加新的具体构建器支持更多产品表示。
  2. 分离复杂对象的创建和表示:更清晰地组织代码。
  3. 灵活性:可以根据需要动态调整构造步骤。

缺点

  1. 增加代码复杂性:需要引入多个类和接口。
  2. 适用场景有限:主要适用于需要分步骤构建的复杂对象。

使用场景

  1. 构建一个由多个组件组成的复杂对象,例如生成器游戏关卡、配置文件生成等。
  2. 需要生成多个不同表示的对象,但构造过程相似。
  3. 希望控制对象的构造步骤,而不直接依赖产品的细节。

构建器模式的设计理念在于简化复杂对象的构建,并提供灵活性以适应变化。

个人经验:

1. 可以和类内类Builder和链式调用一起用,用Builder. SetEngine(x,x),SetWheel(),build() 链式调用构建。

public class Product
{
    // 私有构造函数,防止直接实例化
    private Product() { }
    
    // 产品的属性
    public Type1 Property1 { get; private set; }
    public Type2 Property2 { get; private set; }
    public Type3 Property3 { get; private set; }

    // Builder类
    public class Builder
    {
        private Product _product = new Product();

        // 链式方法,每个都返回Builder实例
        public Builder WithProperty1(Type1 value)
        {
            _product.Property1 = value;
            return this;
        }

        public Builder WithProperty2(Type2 value)
        {
            _product.Property2 = value;
            return this;
        }

        public Builder WithProperty3(Type3 value)
        {
            _product.Property3 = value;
            return this;
        }

        // 最终构建方法
        public Product Build()
        {
            // 可以在这里添加参数验证
            return _product;
        }
    }
}

核心要点:

外部类私有构造函数
内部Builder类
链式方法返回Builder本身
Build()方法返回最终产品

调用方式

var product = new Product.Builder()
    .WithProperty1(value1)
    .WithProperty2(value2)
    .WithProperty3(value3)
    .Build();