我选择了稍微不同的方式(通过实现我自己的SynchronizationContext并使用Task.Yield).这工作正常

然后我意识到会有问题;目前一个协程没有必要完成运行.它可以在其产生的任何时刻优雅地停止.我们可能会有这样的代码：

private IEnumerator Sleep(int milliseconds)
{
    Stopwatch timer = Stopwatch.StartNew();
    do
    {
        yield return null;
    }
    while (timer.ElapsedMilliseconds < milliseconds);
}

private IEnumerator CoroutineMain()
{
    try
    {
        // Do something that runs over several frames
        yield return Coroutine.Sleep(5000);
    }
    finally
    {
        Log("Coroutine finished,either after 5 seconds,or because it was stopped");
    }
}

协调工作通过跟踪堆栈中的所有枚举器来工作. C#编译器生成一个可以被调用的Dispose函数,以确保在CoroutineMain中正确调用’finally’块,即使枚举未完成.这样我们可以优雅地停止一个协同程序,并且仍然通过在堆栈上的所有IEnumerator对象上调用Dispose来确保finally块被调用.这基本上是手动放卷.

当我用异步/等待编写我的实现时,我意识到我们会失去这个功能,除非我错了.然后,我查找了其他协同解决方案,并且它看起来不像Jon Skeet的版本以任何方式处理它.

我可以想到的唯一办法就是拥有自己的定制’Yield’功能,这将检查协同程序是否停止,然后引发一个异常指示.这会传播起来,执行finally块,然后被抓到根部附近的某个地方.我没有找到这个,但第三方代码可能会捕获异常.

我是否误解了某些事情,这样做可能会更容易吗？或者我需要采取例外的方式来做到这一点吗？

编辑：更多信息/代码已被要求,所以这里有一些.我可以保证这只是在一个线程上运行,所以这里没有线程.
我们目前的协同实现看起来有点像这样(这是简化的,但它在这种简单的情况下工作)：

public sealed class Coroutine : IDisposable
{
    private class RoutineState
    {
        public RoutineState(IEnumerator enumerator)
        {
            Enumerator = enumerator;
        }

        public IEnumerator Enumerator { get; private set; }
    }

    private readonly Stack<RoutineState> _enumStack = new Stack<RoutineState>();

    public Coroutine(IEnumerator enumerator)
    {
        _enumStack.Push(new RoutineState(enumerator));
    }

    public bool IsDisposed { get; private set; }

    public void Dispose()
    {
        if (IsDisposed)
            return;

        while (_enumStack.Count > 0)
        {
            DisposeEnumerator(_enumStack.Pop().Enumerator);
        }

        IsDisposed = true;
    }

    public bool Resume()
    {
        while (true)
        {
            RoutineState top = _enumStack.Peek();
            bool movedNext;

            try
            {
                movedNext = top.Enumerator.MoveNext();
            }
            catch (Exception ex)
            {
                // Handle exception thrown by coroutine
                throw;
            }

            if (!movedNext)
            {
                // We finished this (sub-)routine,so remove it from the stack
                _enumStack.Pop();

                // Clean up..
                DisposeEnumerator(top.Enumerator);


                if (_enumStack.Count <= 0)
                {
                    // This was the outer routine,so coroutine is finished.
                    return false;
                }

                // Go back and execute the parent.
                continue;
            }

            // We executed a step in this coroutine. Check if a subroutine is supposed to run..
            object value = top.Enumerator.Current;
            IEnumerator newEnum = value as IEnumerator;
            if (newEnum != null)
            {
                // Our current enumerator yielded a new enumerator,which is a subroutine.
                // Push our new subroutine and run the first iteration immediately
                RoutineState newState = new RoutineState(newEnum);
                _enumStack.Push(newState);

                continue;
            }

            // An actual result was yielded,so we've completed an iteration/step.
            return true;
        }
    }

    private static void DisposeEnumerator(IEnumerator enumerator)
    {
        IDisposable disposable = enumerator as IDisposable;
        if (disposable != null)
            disposable.Dispose();
    }
}

假设我们有如下代码：

private IEnumerator MoveToPlayer()
{
  try
  {
    while (!AtPlayer())
    {
      yield return Sleep(500); // Move towards player twice every second
      CalculatePosition();
    }
  }
  finally
  {
    Log("MoveTo Finally");
  }
}

private IEnumerator OrbLogic()
{
  try
  {
    yield return MoveToPlayer();
    yield return MakeExplosion();
  }
  finally
  {
    Log("OrbLogic Finally");
  }
}

这将通过将OrbLogic枚举器的实例传递给Coroutine,然后运行它来创建.这允许我们每帧都勾选协程.如果玩家杀死了球,那么协奏曲没有完成;处理只是在协同程序中调用.如果MoveTo逻辑上处于“try”块,则在顶层IEnumerator上调用Dispose将在语法上使MoveTo中的finally块执行.然后,OrbLogic中的finally块将执行.
请注意,这是一个简单的案例,案例要复杂得多.

我正在努力在async / await版本中实现类似的行为.此版本的代码看起来像这样(错误检查省略)：

public class Coroutine
{
    private readonly CoroutineSynchronizationContext _syncContext = new CoroutineSynchronizationContext();

    public Coroutine(Action action)
    {
        if (action == null)
            throw new ArgumentNullException("action");

        _syncContext.Next = new CoroutineSynchronizationContext.Continuation(state => action(),null);
    }

    public bool IsFinished { get { return !_syncContext.Next.HasValue; } }

    public void Tick()
    {
        if (IsFinished)
            throw new InvalidOperationException("Cannot resume Coroutine that has finished");

        SynchronizationContext curContext = SynchronizationContext.Current;
        try
        {
            SynchronizationContext.SetSynchronizationContext(_syncContext);

            // Next is guaranteed to have value because of the IsFinished check
            Debug.Assert(_syncContext.Next.HasValue);

            // Invoke next continuation
            var next = _syncContext.Next.Value;
            _syncContext.Next = null;

            next.Invoke();
        }
        finally
        {
            SynchronizationContext.SetSynchronizationContext(curContext);
        }
    }
}

public class CoroutineSynchronizationContext : SynchronizationContext
{
    internal struct Continuation
    {
        public Continuation(SendOrPostCallback callback,object state)
        {
            Callback = callback;
            State = state;
        }

        public SendOrPostCallback Callback;
        public object State;

        public void Invoke()
        {
            Callback(State);
        }
    }

    internal Continuation? Next { get; set; }

    public override void Post(SendOrPostCallback callback,object state)
    {
        if (callback == null)
            throw new ArgumentNullException("callback");

        if (Current != this)
            throw new InvalidOperationException("Cannot Post to CoroutineSynchronizationContext from different thread!");

        Next = new Continuation(callback,state);
    }

    public override void Send(SendOrPostCallback d,object state)
    {
        throw new NotSupportedException();
    }

    public override int Wait(IntPtr[] waitHandles,bool waitAll,int millisecondsTimeout)
    {
        throw new NotSupportedException();
    }

    public override SynchronizationContext CreateCopy()
    {
        throw new NotSupportedException();
    }
}

我没有看到如何使用这个实现与迭代器版本类似的行为.
为长时间的代码提前道歉！

编辑2：新的方法似乎正在运作.它允许我做如下事情：

private static async Task Test()
{
    // Second resume
    await Sleep(1000);
    // Unknown how many resumes
}

private static async Task Main()
{
    // First resume
    await Coroutine.Yield();
    // Second resume
    await Test();
}

这为游戏制作AI提供了非常好的方法.