Question

我创建了一个流畅的构建器样式模式，用于帮助加载我的测试数据。某些方法的顺序很重要，并且想知道管理正确序列的首选方法是什么。

我现在有以下内容：

using NUnit.Framework;

[TestFixture]
public class DataBuilderTests
{
    [Test]
    public void Can_NAME()
    {
        new DataLoader()
            .Start() // must be called first
            .Setup() // then called next
            .LoadEmployees() // optional order not NB
            .LoadProducts() // optional order not NB
            .StartCleanup() // begin cleanup
            .CleanupEmployees() // optional order not NB
            .CleanupProducts() // optional order not NB
            .End();
    }
}

public class DataLoader
{
    public DataBuilderSetup Start()
    {
        return new DataBuilderSetup(this);       
    }
}

public class DataBuilderSetup
{
    private readonly DataLoader _dataLoader;

    public DataBuilderSetup(DataLoader dataLoader)
    {
        _dataLoader = dataLoader;
    }

    public DataBuilderOptions Setup()
    {
        // do setup
        return new DataBuilderOptions(_dataLoader);
    }
}

public class DataBuilderOptions
{
    private readonly DataLoader _dataLoader;

    public DataBuilderOptions(DataLoader dataLoader)
    {
        _dataLoader = dataLoader;
    }

    public DataBuilderOptions LoadEmployees()
    {
        // load
        return this;
    }

    public DataBuilderOptions LoadProducts()
    {
        // load
        return this;
    }

    public DataBuilderCleanupOptions StartCleanup()
    {
        return new DataBuilderCleanupOptions(_dataLoader);
    }
}

public class DataBuilderCleanupOptions
{
    private readonly DataLoader _dataLoader;

    public DataBuilderCleanupOptions(DataLoader dataLoader)
    {
        _dataLoader = dataLoader;
    }

    public DataBuilderCleanupOptions CleanupEmployees()
    {
        // cleanup
        return this;
    }

    public DataBuilderCleanupOptions CleanupProducts()
    {
        // cleanup
        return this;
    }

    public DataLoader End()
    {
        return _dataLoader;
    }
}

Answer 1

在Java中（C＃及其多重继承不应该有任何不同）你可以这样做：

声明一组接口，仅包含一个方法：

Interface DoFirstThing { // could be renamed to "BuilderOnStart" or "BuilderStartingState"
    DoSecondThing doFirst();
}

Interface DoSecondThing {
    DoLastThing doSecond();
}

Interface DoLastThing {
    BuilderReady doLast();
}

Interface BuilderReady {
    Result build();
}

class BuilderWithForcedSequence implements DoFirstThing, DoSecondThing, DoLastThing, BuilderReady {

     // implement all

}

最后你需要一些工厂或工厂方法来为该构建器设置初始状态：

public DoFirstThing createNewBuilderWithForcedSequence(requiredParameters){
    return new BuilderWithForcedSequence(requiredParameters);
}

这将生成构建器，强制排序构建方法（它们应该从doThat重命名为有意义的东西），只能调用doFirst()，之后doSecond() ...等等，直到最终状态，当使用build()方法构建对象时。

Result result = builder.doFirst().doSecond().doLast().build();

编辑：
哎呀，这非常精确你的方法：）

Answer 2

BuilderPattern的一部分优势在于它可以保护消费者免受方法调用强加的“魔术”排序。

我建议您更改设计，以便：

预先提供所有必要的参数，以保护消费者免受对Start和Setup的强制性有序调用的影响。
修改实体的职责，以便可以任意构建它们。

显然这是我的个人偏好。如果此类型构成将由第三方使用的库的一部分，那么我强烈建议不再需要魔术方法排序。如果这只能在内部使用，那么您需要权衡与更改代码相关的成本与不这样做。

Answer 3

您可以将私有队列成员添加到构建器，例如Queue<string>，并在每个构建器步骤中添加操作的名称。

.Build()方法或在您的情况下.End()将检查队列是否按正确的顺序包含正确的操作名称。如果不是，你可以抛出InvalidOperationException

您也可以使用树作为数据结构。通过树，您可以剖析先前构建器步骤中不可用的选项。

但最好考虑其他答案，因为我的方法实际上是一种黑客攻击，它会造成维护问题。

Answer 4

首选方法是不惜一切代价避免它。设计您的构建器，以便明确需要完成的任务。

ObjectBuilder
.Init()
.Optional1()
.Optional3()
.Optional2()
.ToObject()

如果需要先发生某些事情，请在构造函数或工厂方法中执行此操作。然后总是有一个方法来完成构建过程，清理和所有。

Answer 5

您当前的解决方案是我将采用的方法来提供流畅的语法，但我不一定会说它完全遵循构建器模式。从本质上讲，您所做的是将构建器与状态机提供的限制相结合。我发现你所做的事情与其他任何普遍接受的流畅配置都没有什么区别，比如流利的休眠或流畅的断言。

在构建器模式中管理顺序的首选方法是什么？

5 个答案: