c# - 返回自身的 Func<T> 的正确 'T' 是多少？

Question

返回值的函数:

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

有什么想法吗？还是我应该坚持使用可行的解决方案？

Answer 1

而不是使用 Func<T>你可以定义一个 delegate返回 delegate 的值类型。委托(delegate)可用于将函数引用作为参数传递给另一个函数，或者在这种情况下从函数返回函数引用 (docs)。

例子:

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