我想知道在.When
对象中使用方法链接在流畅的界面中实现Builder
条件的最佳方法是什么?
例如,如何在以下示例中实现.WithSkill()
和.When()
方法:
var level = 5;
var ninja = NinjaBuilder
.CreateNinja()
.Named("Ninja Boy")
.AtLevel(level)
.WithShurikens(10)
.WithSkill(Skill.HideInShadows)
.When(level > 3)
.Build()
更新 - 可以找到示例解决方案here。
答案 0 :(得分:82)
我要做的是让NinjaBuilder
将操作保留为代理列表,而不是应用它们,并且仅在调用.Build
时应用它们。这将允许您使它们成为条件:
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;
}
}
当然,这假设在创建构建器时条件是恒定的。如果你想让它不是常数,你可以做这样的事情:
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受到保护,并执行以下操作:
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:
public ConditionalNinjaBuilder WithShurikens(int numShirukens) {
builderActions.Add(n=>n.Shirukens = numShirukens);
return new ConditionalNinjaBuilder(this);
}
这样你只能在第一次调用另一个方法后调用.When
。这具有潜在地允许嵌套/复合条件的额外优点/复杂性。让人惊讶。
答案 1 :(得分:9)
我有一个接口链接的解决方案;我的解决方案唯一的问题是它随着你想要支持的每个新方法的复杂性(规模)而增长。但是,它为用户提供了一个非常棒的API。
让我们考虑您有3种方法,A,B和C,并且您希望在链中使用它们。
我们还要考虑您不希望多次调用任何方法。
e.g。
new Builder().A().B().C(); // OK
new Builder().A().B().A(); // Not OK
这可以通过一些非常棒的实现来实现:
public class Builder : A<Not_A>, B<Not_B>, C<Not_C>, Not_A, Not_B, Not_C, Not_AB, Not_BC, Not_AC, Empty
{
Not_AB A<Not_AB>.A() { return (Not_AB)A(); }
Not_AC A<Not_AC>.A() { return (Not_AC)A(); }
Empty A<Empty>.A() { return (Empty)A(); }
public Not_A A()
{
return (Not_A)this;
}
Not_AB B<Not_AB>.B() { return (Not_AB)B(); }
Not_BC B<Not_BC>.B() { return (Not_BC)B(); }
Empty B<Empty>.B() { return (Empty)B(); }
public Not_B B()
{
return (Not_B)this;
}
Not_AC C<Not_AC>.C() { return (Not_AC)C(); }
Not_BC C<Not_BC>.C() { return (Not_BC)C(); }
Empty C<Empty>.C() { return (Empty)C(); }
public Not_C C()
{
return (Not_C)this;
}
}
public interface Empty { }
public interface A<TRemainder> { TRemainder A(); }
public interface B<TRemainder> { TRemainder B(); }
public interface C<TRemainder> { TRemainder C(); }
public interface Not_A : B<Not_AB>, C<Not_AC> { }
public interface Not_B : A<Not_AB>, C<Not_BC> { }
public interface Not_C : A<Not_AC>, B<Not_BC> { }
public interface Not_AB : C<Empty> { }
public interface Not_BC : A<Empty> { }
public interface Not_AC : B<Empty> { }
然后,将其与Chris Shain的精彩混合使用一堆行动!
我决定实施它。请注意,使用此链接解决方案现在无法再调用任何方法两次。我将您的When
方法作为扩展方法。
这是调用代码:
int level = 5;
var ninja = NinjaBuilder
.CreateNinja()
.Named("Ninja Boy")
.AtLevel(level)
.WithShurikens(10)
.WithSkill(Skill.HideInShadows)
.When(n => n.Level > 3)
.Build();
这是我的忍者和技能课程:
public class Ninja
{
public string Name { get; set; }
public int Level { get; set; }
public int Shurikens { get; set; }
public Skill Skill { get; set; }
}
public enum Skill
{
None = 1,
HideInShadows
}
这是NinjaBuilder类:
public class NinjaBuilder : NinjaBuilder_Sans_Named
{
public static NinjaBuilder CreateNinja() { return new NinjaBuilder(); }
public Stack<Action<Ninja>> _buildActions;
public NinjaBuilder()
{
_buildActions = new Stack<Action<Ninja>>();
}
public override Ninja Build()
{
var ninja = new Ninja();
while (_buildActions.Count > 0)
{
_buildActions.Pop()(ninja);
}
return ninja;
}
public override void AddCondition(Func<Ninja, bool> condition)
{
if (_buildActions.Count == 0)
return;
var top = _buildActions.Pop();
_buildActions.Push(n => { if (condition(n)) { top(n); } });
}
public override Sans_Named_NinjaBuilder Named(string name)
{
_buildActions.Push(n => n.Name = name);
return this;
}
public override Sans_AtLevel_NinjaBuilder AtLevel(int level)
{
_buildActions.Push(n => n.Level = level);
return this;
}
public override Sans_WithShurikens_NinjaBuilder WithShurikens(int shurikenCount)
{
_buildActions.Push(n => n.Shurikens = shurikenCount);
return this;
}
public override Sans_WithSkill_NinjaBuilder WithSkill(Skill skillType)
{
_buildActions.Push(n => n.Skill = skillType);
return this;
}
}
此代码的其余部分只是为了使转换和调用工作的开销:
public abstract class NinjaBuilderBase :
EmptyNinjaBuilder,
Named_NinjaBuilder<Sans_Named_NinjaBuilder>,
AtLevel_NinjaBuilder<Sans_AtLevel_NinjaBuilder>,
WithShurikens_NinjaBuilder<Sans_WithShurikens_NinjaBuilder>,
WithSkill_NinjaBuilder<Sans_WithSkill_NinjaBuilder>
{
public abstract void AddCondition(Func<Ninja, bool> condition);
public abstract Ninja Build();
public abstract Sans_WithSkill_NinjaBuilder WithSkill(Skill skillType);
public abstract Sans_WithShurikens_NinjaBuilder WithShurikens(int shurikenCount);
public abstract Sans_AtLevel_NinjaBuilder AtLevel(int level);
public abstract Sans_Named_NinjaBuilder Named(string name);
}
public abstract class NinjaBuilder_Sans_WithSkill : NinjaBuilderBase,
Sans_WithSkill_NinjaBuilder
{
Sans_Named_WithSkill_NinjaBuilder Named_NinjaBuilder<Sans_Named_WithSkill_NinjaBuilder>.Named(string name) { return (Sans_Named_WithSkill_NinjaBuilder)Named(name); }
Sans_AtLevel_WithSkill_NinjaBuilder AtLevel_NinjaBuilder<Sans_AtLevel_WithSkill_NinjaBuilder>.AtLevel(int level) { return (Sans_AtLevel_WithSkill_NinjaBuilder)AtLevel(level); }
Sans_WithShurikens_WithSkill_NinjaBuilder WithShurikens_NinjaBuilder<Sans_WithShurikens_WithSkill_NinjaBuilder>.WithShurikens(int shurikenCount) { return (Sans_WithShurikens_WithSkill_NinjaBuilder)WithShurikens(shurikenCount); }
}
public abstract class NinjaBuilder_Sans_WithShurikens : NinjaBuilder_Sans_WithSkill,
Sans_WithShurikens_NinjaBuilder,
Sans_WithShurikens_WithSkill_NinjaBuilder
{
Sans_Named_WithShurikens_WithSkill_NinjaBuilder Named_NinjaBuilder<Sans_Named_WithShurikens_WithSkill_NinjaBuilder>.Named(string name) { return (Sans_Named_WithShurikens_WithSkill_NinjaBuilder)Named(name); }
Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder AtLevel_NinjaBuilder<Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder>.AtLevel(int level) { return (Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder)AtLevel(level); }
Sans_Named_WithSkill_NinjaBuilder Named_NinjaBuilder<Sans_Named_WithSkill_NinjaBuilder>.Named(string name) { return (Sans_Named_WithSkill_NinjaBuilder)Named(name); }
Sans_AtLevel_WithShurikens_NinjaBuilder AtLevel_NinjaBuilder<Sans_AtLevel_WithShurikens_NinjaBuilder>.AtLevel(int level) { return (Sans_AtLevel_WithShurikens_NinjaBuilder)AtLevel(level); }
Sans_WithShurikens_WithSkill_NinjaBuilder WithSkill_NinjaBuilder<Sans_WithShurikens_WithSkill_NinjaBuilder>.WithSkill(Skill skillType) { return (Sans_WithShurikens_WithSkill_NinjaBuilder)WithSkill(skillType); }
}
public abstract class NinjaBuilder_Sans_AtLevel : NinjaBuilder_Sans_WithShurikens,
Sans_AtLevel_NinjaBuilder,
Sans_AtLevel_WithShurikens_NinjaBuilder,
Sans_AtLevel_WithSkill_NinjaBuilder,
Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder
{
EmptyNinjaBuilder Named_NinjaBuilder<EmptyNinjaBuilder>.Named(string name) { return Named(name); }
Sans_Named_AtLevel_WithSkill_NinjaBuilder Named_NinjaBuilder<Sans_Named_AtLevel_WithSkill_NinjaBuilder>.Named(string name) { return (Sans_Named_AtLevel_WithSkill_NinjaBuilder)Named(name); }
Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder WithShurikens_NinjaBuilder<Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder>.WithShurikens(int shurikenCount) { return (Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder)WithShurikens(shurikenCount); }
Sans_Named_AtLevel_WithShurikens_NinjaBuilder Named_NinjaBuilder<Sans_Named_AtLevel_WithShurikens_NinjaBuilder>.Named(string name) { return (Sans_Named_AtLevel_WithShurikens_NinjaBuilder)Named(name); }
Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder WithSkill_NinjaBuilder<Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder>.WithSkill(Skill skillType) { return (Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder)WithSkill(skillType); }
Sans_Named_AtLevel_NinjaBuilder Named_NinjaBuilder<Sans_Named_AtLevel_NinjaBuilder>.Named(string name) { return (Sans_Named_AtLevel_NinjaBuilder)Named(name); }
Sans_AtLevel_WithShurikens_NinjaBuilder WithShurikens_NinjaBuilder<Sans_AtLevel_WithShurikens_NinjaBuilder>.WithShurikens(int shurikenCount) { return (Sans_AtLevel_WithShurikens_NinjaBuilder)WithShurikens(shurikenCount); }
Sans_AtLevel_WithSkill_NinjaBuilder WithSkill_NinjaBuilder<Sans_AtLevel_WithSkill_NinjaBuilder>.WithSkill(Skill skillType) { return (Sans_AtLevel_WithSkill_NinjaBuilder)WithSkill(skillType); }
}
public abstract class NinjaBuilder_Sans_Named : NinjaBuilder_Sans_AtLevel,
Sans_Named_NinjaBuilder,
Sans_Named_AtLevel_NinjaBuilder,
Sans_Named_WithShurikens_NinjaBuilder,
Sans_Named_WithSkill_NinjaBuilder,
Sans_Named_WithShurikens_WithSkill_NinjaBuilder,
Sans_Named_AtLevel_WithSkill_NinjaBuilder,
Sans_Named_AtLevel_WithShurikens_NinjaBuilder
{
EmptyNinjaBuilder WithSkill_NinjaBuilder<EmptyNinjaBuilder>.WithSkill(Skill skillType) { return (EmptyNinjaBuilder)WithSkill(skillType); }
EmptyNinjaBuilder WithShurikens_NinjaBuilder<EmptyNinjaBuilder>.WithShurikens(int shurikenCount) { return (EmptyNinjaBuilder)WithShurikens(shurikenCount); }
EmptyNinjaBuilder AtLevel_NinjaBuilder<EmptyNinjaBuilder>.AtLevel(int level) { return (EmptyNinjaBuilder)AtLevel(level); }
Sans_Named_AtLevel_WithShurikens_NinjaBuilder AtLevel_NinjaBuilder<Sans_Named_AtLevel_WithShurikens_NinjaBuilder>.AtLevel(int level) { return (Sans_Named_AtLevel_WithShurikens_NinjaBuilder)AtLevel(level); }
Sans_Named_WithShurikens_WithSkill_NinjaBuilder WithShurikens_NinjaBuilder<Sans_Named_WithShurikens_WithSkill_NinjaBuilder>.WithShurikens(int shurikenCount) { return (Sans_Named_WithShurikens_WithSkill_NinjaBuilder)WithShurikens(shurikenCount); }
Sans_Named_WithShurikens_WithSkill_NinjaBuilder WithSkill_NinjaBuilder<Sans_Named_WithShurikens_WithSkill_NinjaBuilder>.WithSkill(Skill skillType) { return (Sans_Named_WithShurikens_WithSkill_NinjaBuilder)WithSkill(skillType); }
Sans_Named_AtLevel_WithShurikens_NinjaBuilder WithShurikens_NinjaBuilder<Sans_Named_AtLevel_WithShurikens_NinjaBuilder>.WithShurikens(int shurikenCount) { return (Sans_Named_AtLevel_WithShurikens_NinjaBuilder)WithShurikens(shurikenCount); }
Sans_Named_AtLevel_WithSkill_NinjaBuilder WithSkill_NinjaBuilder<Sans_Named_AtLevel_WithSkill_NinjaBuilder>.WithSkill(Skill skillType) { return (Sans_Named_AtLevel_WithSkill_NinjaBuilder)WithSkill(skillType); }
Sans_Named_AtLevel_NinjaBuilder AtLevel_NinjaBuilder<Sans_Named_AtLevel_NinjaBuilder>.AtLevel(int level) { return (Sans_Named_AtLevel_NinjaBuilder)AtLevel(level); }
Sans_Named_WithShurikens_NinjaBuilder WithShurikens_NinjaBuilder<Sans_Named_WithShurikens_NinjaBuilder>.WithShurikens(int shurikenCount) { return (Sans_Named_WithShurikens_NinjaBuilder)WithShurikens(shurikenCount); }
Sans_Named_WithSkill_NinjaBuilder WithSkill_NinjaBuilder<Sans_Named_WithSkill_NinjaBuilder>.WithSkill(Skill skillType) { return (Sans_Named_WithSkill_NinjaBuilder)WithSkill(skillType); }
}
public static class NinjaBuilderExtension
{
public static TBuilderLevel When<TBuilderLevel>(this TBuilderLevel ths, Func<Ninja, bool> condition) where TBuilderLevel : EmptyNinjaBuilder
{
ths.AddCondition(condition);
return ths;
}
}
public interface EmptyNinjaBuilder { void AddCondition(Func<Ninja, bool> condition); Ninja Build(); }
public interface Named_NinjaBuilder<TRemainder> { TRemainder Named(string name); }
public interface AtLevel_NinjaBuilder<TRemainder> { TRemainder AtLevel(int level);}
public interface WithShurikens_NinjaBuilder<TRemainder> { TRemainder WithShurikens(int shurikenCount); }
public interface WithSkill_NinjaBuilder<TRemainder> { TRemainder WithSkill(Skill skillType); }
// level one reductions
public interface Sans_Named_NinjaBuilder :
AtLevel_NinjaBuilder<Sans_Named_AtLevel_NinjaBuilder>,
WithShurikens_NinjaBuilder<Sans_Named_WithShurikens_NinjaBuilder>,
WithSkill_NinjaBuilder<Sans_Named_WithSkill_NinjaBuilder>,
EmptyNinjaBuilder { }
public interface Sans_AtLevel_NinjaBuilder :
Named_NinjaBuilder<Sans_Named_AtLevel_NinjaBuilder>,
WithShurikens_NinjaBuilder<Sans_AtLevel_WithShurikens_NinjaBuilder>,
WithSkill_NinjaBuilder<Sans_AtLevel_WithSkill_NinjaBuilder>,
EmptyNinjaBuilder { }
public interface Sans_WithShurikens_NinjaBuilder :
Named_NinjaBuilder<Sans_Named_WithSkill_NinjaBuilder>,
AtLevel_NinjaBuilder<Sans_AtLevel_WithShurikens_NinjaBuilder>,
WithSkill_NinjaBuilder<Sans_WithShurikens_WithSkill_NinjaBuilder>,
EmptyNinjaBuilder { }
public interface Sans_WithSkill_NinjaBuilder :
Named_NinjaBuilder<Sans_Named_WithSkill_NinjaBuilder>,
AtLevel_NinjaBuilder<Sans_AtLevel_WithSkill_NinjaBuilder>,
WithShurikens_NinjaBuilder<Sans_WithShurikens_WithSkill_NinjaBuilder>,
EmptyNinjaBuilder { }
// level two reductions
// Named
public interface Sans_Named_AtLevel_NinjaBuilder :
WithShurikens_NinjaBuilder<Sans_Named_AtLevel_WithShurikens_NinjaBuilder>,
WithSkill_NinjaBuilder<Sans_Named_AtLevel_WithSkill_NinjaBuilder>,
EmptyNinjaBuilder { }
public interface Sans_Named_WithShurikens_NinjaBuilder :
AtLevel_NinjaBuilder<Sans_Named_AtLevel_WithShurikens_NinjaBuilder>,
WithSkill_NinjaBuilder<Sans_Named_WithShurikens_WithSkill_NinjaBuilder>,
EmptyNinjaBuilder { }
public interface Sans_Named_WithSkill_NinjaBuilder :
AtLevel_NinjaBuilder<Sans_Named_AtLevel_WithShurikens_NinjaBuilder>,
WithShurikens_NinjaBuilder<Sans_Named_WithShurikens_WithSkill_NinjaBuilder>,
EmptyNinjaBuilder { }
// AtLevel
public interface Sans_AtLevel_WithShurikens_NinjaBuilder :
Named_NinjaBuilder<Sans_Named_AtLevel_WithShurikens_NinjaBuilder>,
WithSkill_NinjaBuilder<Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder>,
EmptyNinjaBuilder { }
public interface Sans_AtLevel_WithSkill_NinjaBuilder :
Named_NinjaBuilder<Sans_Named_AtLevel_WithSkill_NinjaBuilder>,
WithShurikens_NinjaBuilder<Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder>,
EmptyNinjaBuilder { }
// WithShurikens
public interface Sans_WithShurikens_WithSkill_NinjaBuilder :
Named_NinjaBuilder<Sans_Named_WithShurikens_WithSkill_NinjaBuilder>,
AtLevel_NinjaBuilder<Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder>,
EmptyNinjaBuilder { }
// level three reductions
// Named
public interface Sans_AtLevel_WithShurikens_WithSkill_NinjaBuilder :
Named_NinjaBuilder<EmptyNinjaBuilder>,
EmptyNinjaBuilder { }
// AtLevel
public interface Sans_Named_WithShurikens_WithSkill_NinjaBuilder :
AtLevel_NinjaBuilder<EmptyNinjaBuilder>,
EmptyNinjaBuilder { }
// WithShurikens
public interface Sans_Named_AtLevel_WithSkill_NinjaBuilder :
WithShurikens_NinjaBuilder<EmptyNinjaBuilder>,
EmptyNinjaBuilder { }
// WithSkill
public interface Sans_Named_AtLevel_WithShurikens_NinjaBuilder :
WithSkill_NinjaBuilder<EmptyNinjaBuilder>,
EmptyNinjaBuilder { }
答案 2 :(得分:6)
您的方法中可以有一个条件可选参数,默认情况下为true
:
.WithSkill(Skill.HideInShadows, when: level > 3)
这当然是非常具体的WithSkill
方法:
public NinjaBuilder WithSkill(Skill skill, bool when = true) {
if (!when) return this;
// ...
}
您可以将其添加到您想要成为条件的其他方法中。
另一个选择是让一个方法嵌套构建器的条件部分:
public NinjaBuilder When(bool condition, Action<NinjaBuilder> then) {
if (condition) then(this);
return this;
}
然后你可以这样写:
.When(level > 3,
then: _ => _.WithSkill(Skill.HideInShadows))
或者像这样:
.When(level > 3, _=>_
.WithSkill(Skill.HideInShadows)
)
这是更通用的,可以与构建器的任何方法一起使用。
你甚至可以添加一个可选的“else”:
public NinjaBuilder When(bool condition, Action<NinjaBuilder> then, Action<NinjaBuilder> otherwise = null) {
if (condition) {
then(this);
}
else if (otherwise != null) {
otherwise(this);
}
return this;
}
或者,作为"mixin":
public interface MBuilder {}
public static class BuilderExtensions {
public static TBuilder When<TBuilder>(this TBuilder self, bool condition, Action<TBuilder> then, Action<TBuilder> otherwise = null)
where TBuilder : MBuilder
{
if (condition) {
then(self);
}
else if (otherwise != null) {
otherwise(self);
}
return self;
}
}
public class NinjaBuilder : MBuilder ...
这当然是一种将“if”语句创建为方法调用的方法。其他方式也可以起作用:
.When(level > 3) // enter "conditional" context
.WithSkill(Skill.HideInShadows)
.End() // exit "conditional" context
在这种情况下,构建器会跟踪它是否应该忽略在条件为false的情况下在“条件”上下文中完成的任何方法调用。 When
将进入上下文,End
将退出该上下文。您还可以进行Otherwise()
调用以标记“其他”上下文。有趣的是,您还可以涵盖其他类似的语句,如循环:
.Do(times: 10) // add 10 shurikens
.AddShuriken()
.End()
在这种情况下,必须记录在“循环”上下文中进行的调用,并在调用End
时播放所需的次数。
因此,上下文是构建器可以处于的一种状态;他们改变了运作方式。您还可以使用堆栈来嵌套上下文以跟踪它们。并且您应该检查某些调用在某些状态下是否有效,如果不是则可以抛出异常。
答案 3 :(得分:6)
您可以考虑编写With的重载版本,在第二个版本中,将Where作为参数:
var level = 5;
var ninja = NinjaBuilder
.CreateNinja()
.Named("Ninja Boy")
.AtLevel(level)
.WithShurikens(10)
.WithSkill(Skill.HideInShadows, Where.Level(l => l > 3))
.Build()
当然,这是基于你将要完全写在哪里作为一个单独的对象的概念,这基本上是这样的:
public sealed static class Where
{
public bool Defense (Func<int, bool> predicate) { return predicate(); }
public bool Dodge (Func<int, bool> predicate) { return predicate(); }
public bool Level (Func<int, bool> predicate) { return predicate(); }
}