Méthode de générateur conditionnel chaînant l'interface fluide

Question

Je me demandais quelle serait la meilleure façon d'implémenter une condition .When Dans une interface fluide en utilisant méthode chaînage dans un objet Builder?

Par exemple, comment pourrais-je implémenter les méthodes .WithSkill() et .When() dans l'exemple suivant:

var level = 5;

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

Mise à jour - Un exemple de solution peut être trouvé ici .

Answer 1

Ce que je ferais, c'est que NinjaBuilder conserve les opérations sous forme de liste de délégués, plutôt que de les appliquer, et les applique uniquement lorsque .Build est appelé. Cela vous permettrait de les rendre conditionnelles:

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

Bien sûr, cela suppose que la condition est constante au moment de la création du générateur. Si vous souhaitez le rendre non constant, vous pouvez faire quelque chose comme ceci à la place:

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

Si vous voulez que When soit un peu plus vérifié par le compilateur, vous pouvez protéger builderActions et faire quelque chose comme ceci:

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

et que les opérations d'origine renvoient un ConditionalNinjaBuilder:

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

De cette façon, vous ne pouvez appeler que .When après avoir appelé une autre méthode pour la première fois. Cela a l'avantage/la complication supplémentaire de permettre potentiellement des conditions imbriquées/composées également. Oui.

Answer 2

J'ai une solution pour chaîner les interfaces; le seul problème avec ma solution est qu'elle grandit en complexité (échelle) avec chaque nouvelle méthode que vous souhaitez prendre en charge. Mais, cela fait une API vraiment géniale pour l'utilisateur.

Considérons que vous disposez de 3 méthodes, A, B et C, et que vous souhaitez les utiliser dans une chaîne.

Considérons également que vous ne voulez pas pouvoir appeler une méthode plus d'une fois.

par exemple.

new Builder().A().B().C(); // OK
new Builder().A().B().A(); // Not OK

Cela peut être accompli avec quelque chose de génial:

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

Et puis, mélangez cela avec la génialité de Chris Shain pour utiliser une pile d'actions!

J'ai décidé de le mettre en œuvre. Notez que vous ne pouvez appeler aucune méthode deux fois maintenant avec cette solution de chaînage. J'ai mis votre méthode When comme méthode d'extension.

Voici le code d'appel:

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

Voici mes cours Ninja et Skill:

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
}

Voici la classe 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;
  }
}

Et le reste de ce code est juste une surcharge pour faire fonctionner les conversions et les appels:

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

Answer 3

Vous pourriez envisager d'écrire des versions surchargées de With, et dans le second, prendre un Where comme argument:

var level = 5;  
var ninja = NinjaBuilder     
     .CreateNinja()
     .Named("Ninja Boy")
     .AtLevel(level)
     .WithShurikens(10)
     .WithSkill(Skill.HideInShadows, Where.Level(l => l > 3))
     .Build() 

Bien sûr, cela repose sur la notion que vous allez écrire Where en tant qu'objet séparé, qui ressemble essentiellement à ceci:

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

}

Answer 4

Vous pouvez avoir un paramètre facultatif conditionnel dans votre méthode qui est true par défaut:

.WithSkill(Skill.HideInShadows, when: level > 3)

Ce sera bien sûr très spécifique à la méthode WithSkill:

public NinjaBuilder WithSkill(Skill skill, bool when = true) {
  if (!when) return this;
  // ...
}

Vous pouvez également l'ajouter à d'autres méthodes que vous souhaitez également conditionner.

Une autre option consiste à avoir une méthode qui imbrique les parties conditionnelles du générateur:

public NinjaBuilder When(bool condition, Action<NinjaBuilder> then) {
  if (condition) then(this);
  return this;
}

Ensuite, vous pouvez l'écrire comme ceci:

.When(level > 3, 
  then: _ => _.WithSkill(Skill.HideInShadows))

Ou comme ça:

.When(level > 3, _=>_
  .WithSkill(Skill.HideInShadows)
)

Ceci est plus générique et peut être utilisé avec toutes les méthodes du générateur.

Vous pouvez même ajouter un "else" facultatif:

public NinjaBuilder When(bool condition, Action<NinjaBuilder> then, Action<NinjaBuilder> otherwise = null) {
  if (condition) {
    then(this);
  }
  else if (otherwise != null) {
    otherwise(this);
  }
  return this;
}

Ou, en tant que "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 ...

C'est bien sûr un moyen de créer des instructions "if" en tant qu'appels de méthode. D'autres moyens pourraient également fonctionner:

.When(level > 3) // enter "conditional" context
  .WithSkill(Skill.HideInShadows)
.End() // exit "conditional" context

Dans ce cas, le générateur garde une trace s'il doit ignorer tout appel de méthode effectué dans un contexte "conditionnel" si la condition est fausse. When entrerait dans le contexte, End le sortirait. Vous pouvez également avoir un appel Otherwise() pour marquer le contexte "else". Chose intéressante, vous pouvez également couvrir d'autres instructions comme celle-ci, comme les boucles:

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

Dans ce cas, les appels effectués dans le contexte "boucle" doivent être enregistrés et reproduits le nombre de fois souhaité lorsque End est appelé.

Ainsi, les contextes sont une sorte d'état où le constructeur peut être; ils changent son fonctionnement. Vous pouvez également imbriquer des contextes en utilisant une pile pour en garder la trace. Et vous devriez vérifier si certains appels sont valides dans certains états et peut-être lever des exceptions s'ils ne le sont pas.