条件生成器方法链接 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屋!