C# Building Fluent API for method invocations

What do I have to do to say that InvokeMethod can invoke a method and when using special options like Repeat it shall exexute after the Repeat.

My problem for now is that the method will already exexute before it knows that it has to be called 100 times.

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

MethodExpression

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

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

Use a final method ("go", or "execute") to actually kick things off.

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

What you've provided looks a bit like programming a workflow or state machine. In order to capture invocations and respect conditions during execution, you'd need to change your approach slightly.

Instead of invoking actions as they come in, consider pushing your actions into a queue and then providing an mechanism to run the state machine.

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

There are a lot of ways to skin this cat, but I think one source of this difficulty is in the fact that you actually invoke the method within the InvokeMethod() method (go figure!).

Typically, we use fluent APIs to turn syntax that is evaluated from the inside-out into something that can be expressed in a left-to-right fashion. Thus, the expression builder components of the interface are used to build up state throughout the expression, and only at the end does the "real work" happen.

One solution to your immediate problem is to queue up each action with its associated options (invocation conditions, repeat count, etc.), and add some ExecuteAll() method to MethodExecuter that dequeues and executes the fully configured actions at the end of the member chain.

Another solution would be to put all of the execution options inside the InvokeMethod() method; something like:

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

This method would look something like:

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

I haven't worked through this in Visual Studio, but the other items would be something like:

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

Note that RepeatCount and Action are not exposed on the interface. This way, you will not see these members when calling .Invoke(x => x., but will have access to them when using the concrete ExecutionBuilder class inside the Invoke() method.

You could have a SetInvokeMethod and an Execute Method.

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

In a sentence, your code is too "eager". The InvokeMethod method is called, and performs the action, before your fluent grammar structure tells your code how many times it should repeat.

To change this, try also specifying the method you are invoking as a private field in your methodInvoker, then include a command that is a "trigger" to actually perform the commands. The key is "lazy evaluation"; in a fluent interface, nothing should be done until it has to; that way you have most of the control over when it does happen.

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