条件生成器方法链接 Fluent 接口 [英] Conditional Builder Method Chaining Fluent Interface

问题描述

我想知道在 流畅的界面中使用 方法链 在 .When 条件中实现 .When 条件的最佳方法是什么>Builder 对象?

I was wondering what would be the best way to implement a .When condition in a fluent interface using method chaining in a Builder object?

例如，我将如何在以下示例中实现 .WithSkill() 和 .When() 方法:

For instance how would I implement the .WithSkill() and .When() methods in the following example:

var level = 5;

var ninja = NinjaBuilder
    .CreateNinja()
    .Named("Ninja Boy")
    .AtLevel(level)
    .WithShurikens(10)
    .WithSkill(Skill.HideInShadows)
        .When(level > 3)
    .Build()

更新 - 可以找到示例解决方案 这里.

Update - A sample solution can be found here.

推荐答案

我要做的是让 NinjaBuilder 将操作保留为委托列表，而不是应用它们，并且只应用它们当 .Build 被调用时.这将允许您将它们设置为有条件的:

What I'd do is have NinjaBuilder keep the operations as a list of delegates, rather than applying them, and only apply them when .Build is called. This would allow you to make them conditional:

public class NinjaBuilder { 
    List<Action<Ninja>> builderActions = new List<Action<Ninja>>();

    public Ninja Build() {
        var ninja = new Ninja();
        builderActions.ForEach(ba => ba(ninja));
        return ninja;
    }

    public NinjaBuilder WithShurikens(int numShirukens) {
        builderActions.Add(n=>n.Shirukens = numShirukens);
        return this;
    }

    public NinjaBuilder When(Boolean condition) {
        if (!condition) // If the condition is not met, remove the last action
            builderActions.RemoveAt(builderActions.Length - 1);
        return this;
    }
}

当然，这假设条件在构建器创建时是恒定的.如果你想让它变得非常，你可以做这样的事情:

Of course, this assumes that the condition is constant at the time of builder creation. If you want to make it non-constant, you could do something like this instead:

    public NinjaBuilder When(Func<Boolean> condition) {
        var oldAction = builderActions[builderActions.Length - 1];
        builderActions[builderActions.Length - 1] = n => { if (condition()) { oldAction(n); } }
        return this;
    }

如果您希望 When 被更多的编译器检查，您可以保护 builderActions 并执行以下操作:

If you want When be somewhat more compiler checked, you can make builderActions protected and do something like this:

public class ConditionalNinjaBuilder : NinjaBuilder {
    public ConditionalNinjaBuilder(NinjaBuilder wrappedBuilder) {            
        // Since someone might call .WithShirukens on the wrapping
        // builder directly, we should make sure that our actions 
        // list is the same instance as the one in our wrapped builder
        builderActions = wrappedBuilder.builderActions;
    }

    public ConditionalNinjaBuilder When(Func<Boolean> condition) {
        var oldAction = builderActions[builderActions.Length - 1];
        builderActions[builderActions.Length - 1] = n => { if (condition()) { oldAction(n); } }
        return this;
    }
}

并让原始操作返回一个 ConditionalNinjaBuilder:

and have the original operations return a ConditionalNinjaBuilder:

    public ConditionalNinjaBuilder WithShurikens(int numShirukens) {
        builderActions.Add(n=>n.Shirukens = numShirukens);
        return new ConditionalNinjaBuilder(this);
    }

那样你只能在第一次调用另一个方法后调用.When.这也有可能允许嵌套/复合条件的额外优势/复杂性.哎呀.

That way you can only call .When after first calling another method. This has the additional advantage/complication of potentially allowing for nested/compounded conditionals, too. Yikes.

这篇关于条件生成器方法链接 Fluent 接口的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！