반응형
조건부 빌더 메서드 체인 Fluent 인터페이스
객체 에서 메소드 체인 을 사용하여 유창한 인터페이스.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()
업데이트 -샘플 솔루션은 여기 에서 찾을 수 있습니다 .
내가 할 일은 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다른 메서드를 처음 호출 한 후에 만 호출 할 수 있습니다 . 이것은 잠재적으로 중첩 / 복합 조건을 허용하는 추가적인 이점 / 복잡성을 가지고 있습니다. Yikes.
인터페이스 체인에 대한 솔루션이 있습니다. 내 솔루션의 유일한 문제는 지원하려는 모든 새로운 방법으로 인해 복잡성 (규모)이 증가한다는 것입니다. 그러나 이것은 사용자에게 정말 멋진 API를 제공합니다.
A, B, C의 세 가지 방법이 있고이를 체인에서 사용하고 싶다고 가정 해 보겠습니다.
또한 어떤 메서드도 두 번 이상 호출 할 수 없도록하겠습니다.
예 :
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 { }
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()
물론 이것은 Where를 완전히 별도의 객체로 작성할 것이라는 개념을 바탕으로합니다. 본질적으로 다음과 같습니다.
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(); }
}
메서드 true에 기본적으로 조건부 선택적 매개 변수가있을 수 있습니다 .
.WithSkill(Skill.HideInShadows, when: level > 3)
물론 이것은 WithSkill방법 에 따라 매우 구체적입니다 .
public NinjaBuilder WithSkill(Skill skill, bool when = true) {
if (!when) return this;
// ...
}
You could add it to other methods that you want to be conditional too.
Another option is to have a method that nests the conditional parts of the builder:
public NinjaBuilder When(bool condition, Action<NinjaBuilder> then) {
if (condition) then(this);
return this;
}
Then you can write it like this:
.When(level > 3,
then: _ => _.WithSkill(Skill.HideInShadows))
Or like this:
.When(level > 3, _=>_
.WithSkill(Skill.HideInShadows)
)
This is more generic and can be used with any methods of the builder.
You can even add an optional "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;
}
Or, as a "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 ...
This is of course a way to create "if" statements as method calls. Other ways could also work:
.When(level > 3) // enter "conditional" context
.WithSkill(Skill.HideInShadows)
.End() // exit "conditional" context
In this case, the builder keeps track whether it should ignore any method calls that are done in a "conditional" context if the condition is false. When would enter the context, End would exit it. You could also have an Otherwise() call to mark the "else" context. Interestingly enough, you could also cover other statements like this, like loops:
.Do(times: 10) // add 10 shurikens
.AddShuriken()
.End()
In this case, the calls made in "loop" context must be recorded and played-back the desired number of times when End is called.
So, contexts are a kind of state the builder can be at; they change how it operates. You could also nest contexts, using a stack to keep track of them. And you should check if certain call are valid at certain states and maybe throw exceptions if they aren't.
ReferenceURL : https://stackoverflow.com/questions/10046629/conditional-builder-method-chaining-fluent-interface
반응형
'programing' 카테고리의 다른 글
| 이메일을 받고 웹 애플리케이션에서 처리하는 방법 (0) | 2021.01.14 |
|---|---|
| 새로운 Number () 대 Number () (0) | 2021.01.14 |
| LINQ에서 Union All을 사용하는 방법은 무엇입니까? (0) | 2021.01.14 |
| Cassandra column family의 모든 데이터를 삭제하려면 어떻게해야합니까? (0) | 2021.01.14 |
| DOM 이벤트를 복제하거나 다시 배포하는 방법은 무엇입니까? (0) | 2021.01.14 |