C# 为方法调用构建 Fluent API

Question

我必须做什么才能说 InvokeMethod 可以调用一个方法，并且当使用 Repeat 等特殊选项时，它将在 Repeat 之后执行。

我现在的问题是，该方法在知道必须调用 100 次之前就已经执行了。

class Program
{
    static void Main()
    {
        const bool shouldRun = true;

        new MethodExecuter()
            .ForAllInvocationsUseCondition(!Context.WannaShutDown)
                .InvokeMethod(A.Process).Repeat(100)
                .When(shouldRun).ThenInvokeMethod(B.Process).Repeat(10)
            .ForAllInvocationsUseCondition(Context.WannaShutDown)
                .When(shouldRun).ThenInvokeMethod(C.Process);
    }
}

方法表达式

public class MethodExpression
{
    private bool _isTrue = true;
    private readonly MethodExecuter _methodExecuter;
    public MethodExpression(bool isTrue, MethodExecuter methodExecuter)
    {
        _isTrue = isTrue;
        _methodExecuter = methodExecuter;
    }

    public MethodExecuter ThenInvokeMethod(Action action)
    {
        if (_isTrue)
        {
            action.Invoke();
            _isTrue = false;
        }
        return _methodExecuter;
    }
}

方法执行器

public class MethodExecuter
{
    private bool _condition;
    private int _repeat = 1;

    public MethodExpression When(bool isTrue)
    {
        return new MethodExpression(isTrue && _condition, this);
    }

    public MethodExecuter InvokeMethod(Action action)
    {
        if (_condition)
        {
            for (int i = 1; i <= _repeat; i++)
            {
                action.Invoke();
            }
        }
        return this;
    }

    public MethodExecuter ForAllInvocationsUseCondition(bool condition)
    {
        _condition = condition;
        return this;
    }

    public MethodExecuter Repeat(int repeat)
    {
        _repeat = repeat;
        return this;
    }
}

Answer 1

使用最终方法（“go”或“execute”）来真正开始工作。

      new MethodExecuter()
        .ForAllInvocationsUseCondition(!Context.WannaShutDown)
            .InvokeMethod(A.Process).Repeat(100)
            .When(shouldRun).ThenInvokeMethod(B.Process).Repeat(10)
        .ForAllInvocationsUseCondition(Context.WannaShutDown)
            .When(shouldRun).ThenInvokeMethod(C.Process)
            .Go();

Answer 2

您提供的内容看起来有点像对工作流程或状态机进行编程。为了在执行期间捕获调用并遵守条件，您需要稍微改变您的方法。

考虑将操作推入队列，然后提供运行状态机的机制，而不是在操作进入时调用操作。

new MethodInvoker()
       .ForAllInvocationsUseCondition(true)
           .InvokeMethod( Process.A ).Repeat(100)
       .Run();

Answer 3

有很多方法可以给这只猫剥皮，但我认为这种困难的根源之一是您实际上在 InvokeMethod() 方法中调用了该方法（看图！）。

通常，我们使用流畅的 API 将从内到外评估的语法转换为可以从左到右的方式表达的语法。因此，接口的表达式构建器组件用于在整个表达式中构建状态，并且只有在最后才会发生“真正的工作”。

解决当前问题的一种解决方案是将每个操作及其相关选项（调用条件、重复计数等）排队，并向 MethodExecuter 添加一些 ExecuteAll() 方法在成员链末端出列并执行完全配置的操作。

另一种解决方案是将所有执行选项放在 InvokeMethod() 方法中；类似于：

.Invoke(x => x.Method(A.Process).Repeat(100))

此方法看起来类似于：

public MethodExecuter Invoke(Action<IExecutionBuilder> executionBuilder)
 {
     var builder = new ExecutionBuilder();
      executionBuilder(builder);

      var action = builder.Action; 
      var repeat = builder.RepeatCount;

      if (_condition)
      {
          for (int i = 1; i <= repeat; i++)
            {
                action();
            }
      }

      return this;
 }

我还没有在 Visual Studio 中完成此操作，但其他项目类似于：

public interface IExecutionBuilder
 {
     IExecutionBuilder Method(Action action);
      IExecutionBuilder Repeat(int count);
 }

 public class ExecutionBuilder : IExecutionBuilder
 {
      public ExecutionBuilder()
      {
          RepeatCount = 1; // default to repeat once
            Action = () => {}; // default to do nothing, but not null
      }

     public IExecutionBuilder Method(Action action)
      {
          Action = action;
          return this;
      }

      public IExecutionBuilder Repeat(int repeat)
      {
          RepeatCount = repeat;
                  return this;
      }

      public int RepeatCount { get; private set; }
      public Action Action { get; private set; }
 }

请注意，RepeatCount 和 Action 是不暴露在接口上。这样，您在调用 .Invoke(x => x. 时将看不到这些成员，但在使用 ExecutionBuilder 内的具体 ExecutionBuilder 类时可以访问它们。代码>Invoke() 方法。

Answer 4

您可以有一个 SetInvokeMethod 和一个 Execute 方法。

SetInvokeMethod(Action).Repeat(100).Execute()

Answer 5

一句话，你的代码太“渴望”了。在流畅的语法结构告诉代码应该重复多少次之前，会调用 InvokeMethod 方法并执行操作。

要更改此设置，请尝试将要调用的方法指定为 methodInvoker 中的私有字段，然后包含一个作为实际执行命令的“触发器”的命令。关键是“懒惰评价”；在流畅的界面中，除非必要，否则什么都不应该做；这样你就可以控制事情发生的时间。

public class FluentMethodInvoker
{
    Predicate condition = ()=>true;
    Predicate allCondition = null;
    Action method = ()=> {return;};
    bool iterations = 1;
    FluentMethodInvoker previous = null;

    public FluentMethodInvoker(){}
    private FluentMethodInvoker(FluentMethodInvoker prevNode)
    { previous = prevNode; }

    public FluentMethodInvoker InvokeMethod(Action action)
    {
        method = action;
    }

    //Changed "When" to "If"; the function does not wait for the condition to be true
    public FluentMethodInvoker If(Predicate pred)
    {
        condition = pred;
        return this;
    }

    public FluentMethodInvoker ForAllIf(Predicate pred)
    {
        allCondition = pred;
        return this;
    }

    private bool CheckAllIf()
    {
        return allCondition == null 
                ? previous == null
                   ? true
                   : previous.CheckAllIf();
                : allCondition;
    }

    public FluentMethodInvoker Repeat(int repetitions)
    {
        iterations = repetitions;
        return this;
    }

    //Merging MethodExecuter and MethodExpression, by chaining instances of FluentMethodInvoker
    public FluentMethodInvoker Then()
    {
        return new FluentMethodInvoker(this);
    }

    //Here's your trigger
    public void Run()
    {
        //goes backward through the chain to the starting node
        if(previous != null) previous.Run();

        if(condition && CheckAllIf())    
           for(var i=0; i<repetitions; i++)
              method();

        return;
    }
}

//usage
class Program
{
    static void Main()
    {
        const bool shouldRun = true;

        var invokerChain = new FluentMethodInvoker()
            .ForAllIf(!Context.WannaShutDown)
                .InvokeMethod(A.Process).Repeat(100)
                .When(shouldRun)
            .Then().InvokeMethod(B.Process).Repeat(10)
            .ForAllIf(Context.WannaShutDown)
                .When(shouldRun)
            .Then().InvokeMethod(C.Process);

        //to illustrate that the chain doesn't have to execute immediately when being built
        invokerChain.Run();
    }
}