c# सशर्त बिल्डर विधि चेनिंग फ्लुएंट इंटरफेस




design-patterns builder (4)

मैं सोच रहा था कि एक कार्यान्वयन का सबसे अच्छा तरीका क्या होगा .When एक Builder ऑब्जेक्ट में विधि श्रृंखला का उपयोग कर एक धाराप्रवाह इंटरफ़ेस में स्थिति?

उदाहरण के लिए मैं निम्नलिखित उदाहरण में .WithSkill() और .WithSkill() .When() विधियों को कैसे लागू .WithSkill() :

var level = 5;

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

अद्यतन - यहां एक नमूना समाधान पाया जा सकता here


आपके पास आपकी विधि में एक सशर्त वैकल्पिक पैरामीटर हो सकता है जो डिफ़ॉल्ट रूप से 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)
)

यह अधिक सामान्य है और निर्माता के किसी भी तरीके से इसका उपयोग किया जा सकता है।

आप एक वैकल्पिक "अन्य" भी जोड़ सकते हैं:

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

इस मामले में, बिल्डर ट्रैक रखता है कि क्या स्थिति को गलत होने पर "सशर्त" संदर्भ में किए गए किसी भी विधि कॉल को अनदेखा करना चाहिए या नहीं। संदर्भ When दर्ज करेंगे, End इसे बाहर निकल जाएगा। आप "अन्य" संदर्भ को चिह्नित करने के लिए Otherwise() कॉल भी कर सकते हैं। दिलचस्प बात यह है कि आप इस तरह के अन्य बयान भी कवर कर सकते हैं, जैसे लूप:

.Do(times: 10) // add 10 shurikens
  .AddShuriken()
.End()

इस मामले में, "लूप" संदर्भ में किए गए कॉल रिकॉर्ड किए जाने चाहिए और End में वांछित संख्या को खेला जाना चाहिए जब End कहा जाता है।

तो, संदर्भ एक प्रकार का राज्य है जिस पर बिल्डर हो सकता है; वे बदलते हैं कि यह कैसे काम करता है। आप ट्रैक रखने के लिए एक ढेर का उपयोग करके, संदर्भों को घोंसला भी कर सकते हैं। और आपको यह जांचना चाहिए कि कुछ राज्यों में कुछ कॉल मान्य हैं या नहीं, अगर वे नहीं हैं तो अपवाद फेंक दें।


मैं क्या करूँगा NinjaBuilder को उनकी 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.Remove(builderActions.Length - 1);
        return this;
    }
}

बेशक, यह मानता है कि बिल्डर निर्माण के समय स्थिति स्थिर है। यदि आप इसे निरंतर बनाना चाहते हैं, तो आप इसके बजाय ऐसा कुछ कर सकते हैं:

    public NinjaBuilder When(Func<Boolean> condition) {
        var oldAction = builderActions[builderActions.Length - 1];
        builderActions[builderActions.Length - 1] = n => condition() ? oldAction(n) : n;
        return 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 => condition() ? oldAction(n) : n;
        return this;
    }
}

और मूल संचालन एक ConditionalNinjaBuilder वापस आते हैं:

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

इस तरह आप केवल कॉल कर सकते हैं .When फिर पहली विधि को कॉल करने के बाद। इसमें संभावित रूप से नेस्टेड / मिश्रित सशर्तों की अनुमति देने का अतिरिक्त लाभ / जटिलता भी है। ओह।


मेरे पास इंटरफेस चेनिंग का समाधान है; मेरे समाधान के साथ एकमात्र समस्या यह है कि यह हर नई विधि के साथ जटिलता (स्केल) में बढ़ता है जिसे आप समर्थन देना चाहते हैं। लेकिन, यह उपयोगकर्ता के लिए वास्तव में एक शानदार एपीआई बनाता है।

आइए मान लें कि आपके पास 3 विधियां, ए, बी, और सी हैं, और आप उन्हें श्रृंखला में उपयोग करना चाहते हैं।

आइए यह भी मान लें कि आप किसी भी विधि को एक से अधिक बार कॉल करने में सक्षम नहीं होना चाहते हैं।

जैसे

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> { }

और फिर, क्रिस शाइन की उत्कृष्टता के साथ कार्यों के ढेर का उपयोग करने के लिए इसे मिलाएं!

मैंने इसे लागू करने का फैसला किया। ध्यान दें कि आप इस श्रृंखला समाधान के साथ अब दो बार किसी भी विधि को कॉल नहीं कर सकते हैं। मैंने आपकी विधि को एक विस्तार विधि के रूप में रखा है।

यहां कॉलिंग कोड है:

  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
}

यह निंजाबिल्डर वर्ग है:

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 { }

आप विद के अधिभारित संस्करणों को लिखने पर विचार कर सकते हैं, और दूसरे में, एक तर्क के रूप में कहां लें:

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(); }

}




method-chaining