c#

一个返回值的函数：

public object ReturnValue() { return new object(); }
Func<object> funcReturnValue = ReturnValue;

一个返回一个返回值的函数的函数：

public Func<object> ReturnFunc() { return ReturnValue; }
Func<Func<object>> funcReturnFunc = ReturnFunc;

到现在为止还挺好。我在使用返回自身的函数时遇到问题：

public *something* ReturnSelf() { return ReturnSelf; }
Func<*something*> funcReturnSelf = ReturnSelf;

显然，*something*将是Func<T>某种形式，但我不确定是什么。乍一看，我猜这将是无限递归的，因为ReturnSelf
返回一个函数，该函数返回一个返回函数的函数......

上下文：使用状态函数的状态机。使用类变量来保持当前状态可以正常工作：

private Action _currentState;

private void StateOne() {
    if (IsTuesday) {
        _currentState = StateTwo;
    }
}

prvivate void StateTwo() {
    if (IsRaining) {
        _currentState = StateOne;
    }
}

private void StateEngine() {
    while (true) {
        _currentState();
        // set tuesday/raining/etc.
    }
}

...但这感觉太像将状态保持在全局中。我更喜欢更接近的东西：

private Func<*somthing*> StateOne() {
    if (IsTuesday) {
        return StateTwo;
    } else {
        return StateOne;
    }
}

prvivate Func<*something*> StateTwo() {
    if (IsRaining) {
        return StateOne;
    } else {
        return StateTwo;
    }
}

private void StateEngine() {
    Func<*something*> currentState = StateOne;
    while (true) {
        Func<*something*> nextState = currentState();
        // set tuesday/raining/etc.
        currentState = nextState;
    }
}

有任何想法吗？还是我应该坚持使用有效的解决方案？

回答

class Program
{

  private delegate StateDelegate StateDelegate();

  public static void Main(string[] args)
  {
    Program program = new Program();
    StateDelegate stateHandler = program.HandleStateOne;
    
    // Execute HandleStateOne, returns HandleStateTwo
    stateHandler = stateHandler.Invoke(); 

    // Execute HandleStateTwo, returns reference to HandleStateOne    
    stateHandler = stateHandler.Invoke();
  }

  private StateDelegate HandleStateOne()
  {
    // Do something state specific...
    return HandleStateTwo;
  }

  private StateDelegate HandleStateTwo()
  {
    // Do something state specific...
    return HandleStateOne;
  }

  // Literally return reference to the function itself
  private StateDelegate ReturnSelf()
  {
    return ReturnSelf;
  }
}