我使用 C# 迭代器替代协程，它一直运行良好。我想切换到 async/await，因为我认为它的语法更清晰并且它给了我类型安全性。 In this (outdated) blog post, Jon Skeet shows a possible way to implement it .
我选择了一种稍微不同的方式(通过实现我自己的 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” block ，即使枚举未完成也是如此。通过这种方式，我们可以优雅地停止协程，并仍然确保调用 finally block ，方法是对堆栈中的所有 IEnumerator 对象调用 Dispose。这基本上是手动展开。
当我用 async/await 编写我的实现时，我意识到我们会失去这个特性，除非我弄错了。然后我查找了其他协程解决方案，但 Jon Skeet 的版本似乎也没有以任何方式处理它。
我能想到的处理这个问题的唯一方法是拥有我们自己的自定义“Yield”函数，它会检查协程是否已停止，然后引发一个异常来指示这一点。这会向上传播，执行 finally block ，然后在根附近的某个地方被捕获。不过我不觉得这很漂亮，因为第 3 方代码可能会捕获异常。
我是不是误会了什么，这有可能以更简单的方式进行吗？或者我是否需要采用异常(exception)方式来执行此操作？
编辑:已请求更多信息/代码，所以这里有一些。我可以保证这将仅在单个线程上运行，因此这里不涉及线程。 我们当前的协程实现看起来有点像这样(这是简化的，但它适用于这种简单的情况):
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 枚举器的实例传递给协程，然后运行它来创建。这允许我们在每一帧都勾选协程。 如果玩家杀死球体，协程不会结束运行； Dispose 只是在协程上调用。如果 MoveTo 在逻辑上位于“try” block 中，那么在顶部 IEnumerator 上调用 Dispose 将在语义上使 finally block 位于 MoveTo 执行。然后 OrbLogic 中的 finally block 将执行。
请注意，这是一个简单的案例，案例要复杂得多。
我正在努力在异步/等待版本中实现类似的行为。此版本的代码如下所示(省略了错误检查):
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 的非常好的方法。
最佳答案
已更新，后续博文: Asynchronous coroutines with C# 8.0 and IAsyncEnumerable .
I use C# iterators as a replacement for coroutines, and it has been working great. I want to switch to async/await as I think the syntax is cleaner and it gives me type safety...
IMO，这是一个非常有趣的问题，尽管我花了一段时间才完全理解它。也许，您没有提供足够的示例代码来说明这个概念。一个完整的应用程序会有所帮助，所以我会先尝试填补这个空白。下面的代码说明了我理解的使用模式，如果我错了请指正:
using System;
using System.Collections;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
namespace ConsoleApplication
{
// https://stackoverflow.com/q/22852251/1768303
public class Program
{
class Resource : IDisposable
{
public void Dispose()
{
Console.WriteLine("Resource.Dispose");
}
~Resource()
{
Console.WriteLine("~Resource");
}
}
private IEnumerator Sleep(int milliseconds)
{
using (var resource = new Resource())
{
Stopwatch timer = Stopwatch.StartNew();
do
{
yield return null;
}
while (timer.ElapsedMilliseconds < milliseconds);
}
}
void EnumeratorTest()
{
var enumerator = Sleep(100);
enumerator.MoveNext();
Thread.Sleep(500);
//while (e.MoveNext());
((IDisposable)enumerator).Dispose();
}
public static void Main(string[] args)
{
new Program().EnumeratorTest();
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);
GC.WaitForPendingFinalizers();
Console.ReadLine();
}
}
}
此处，Resource.Dispose 因 ((IDisposable)enumerator).Dispose() 而被调用。如果我们不调用 enumerator.Dispose()，那么我们将不得不取消注释 //while (e.MoveNext()); 并让迭代器优雅地完成, 以进行适当的展开。
现在，我认为用 async/await 实现它的最好方法是使用 custom awaiter :
using System;
using System.Collections;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
namespace ConsoleApplication
{
// https://stackoverflow.com/q/22852251/1768303
public class Program
{
class Resource : IDisposable
{
public void Dispose()
{
Console.WriteLine("Resource.Dispose");
}
~Resource()
{
Console.WriteLine("~Resource");
}
}
async Task SleepAsync(int milliseconds, Awaiter awaiter)
{
using (var resource = new Resource())
{
Stopwatch timer = Stopwatch.StartNew();
do
{
await awaiter;
}
while (timer.ElapsedMilliseconds < milliseconds);
}
Console.WriteLine("Exit SleepAsync");
}
void AwaiterTest()
{
var awaiter = new Awaiter();
var task = SleepAsync(100, awaiter);
awaiter.MoveNext();
Thread.Sleep(500);
//while (awaiter.MoveNext()) ;
awaiter.Dispose();
task.Dispose();
}
public static void Main(string[] args)
{
new Program().AwaiterTest();
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);
GC.WaitForPendingFinalizers();
Console.ReadLine();
}
// custom awaiter
public class Awaiter :
System.Runtime.CompilerServices.INotifyCompletion,
IDisposable
{
Action _continuation;
readonly CancellationTokenSource _cts = new CancellationTokenSource();
public Awaiter()
{
Console.WriteLine("Awaiter()");
}
~Awaiter()
{
Console.WriteLine("~Awaiter()");
}
public void Cancel()
{
_cts.Cancel();
}
// let the client observe cancellation
public CancellationToken Token { get { return _cts.Token; } }
// resume after await, called upon external event
public bool MoveNext()
{
if (_continuation == null)
return false;
var continuation = _continuation;
_continuation = null;
continuation();
return _continuation != null;
}
// custom Awaiter methods
public Awaiter GetAwaiter()
{
return this;
}
public bool IsCompleted
{
get { return false; }
}
public void GetResult()
{
this.Token.ThrowIfCancellationRequested();
}
// INotifyCompletion
public void OnCompleted(Action continuation)
{
_continuation = continuation;
}
// IDispose
public void Dispose()
{
Console.WriteLine("Awaiter.Dispose()");
if (_continuation != null)
{
Cancel();
MoveNext();
}
}
}
}
}
当需要放松时，我在 Awaiter.Dispose 中请求取消并将状态机驱动到下一步(如果有挂起的继续)。这导致观察到 Awaiter.GetResult 中的取消(由编译器生成的代码调用)。这会抛出 TaskCanceledException 并进一步展开 using 语句。因此，Resource 得到了正确处理。最后，任务转换为取消状态 (task.IsCancelled == true)。
IMO，这是比在当前线程上安装自定义同步上下文更简单直接的方法。它可以很容易地适应多线程(更多细节 here )。
与 IEnumerator/yield 相比，这确实会给您更多的自由。您可以在协程逻辑中使用 try/catch，您可以直接通过 Task 对象观察异常、取消和结果。
已更新，据我所知，当谈到 async 状态机时，迭代器生成的 IDispose 没有类比。当你想取消/解除它时，你真的必须将状态机驱动到尽头。如果你想解释 try/catch 的一些疏忽使用以防止取消，我认为你能做的最好的事情就是检查 _continuation 是否在 Awaiter.Cancel(在 MoveNext 之后)并抛出致命异常 out-of-the-band (使用辅助 async void 方法)。
关于c# - Async/await 作为协程的替代品，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22852251/