在 C# 中使用 async/await 时，一般规则是避免使用 async void，因为这几乎是一劳永逸，而不是一个任务。说得通。奇怪的是，本周早些时候我正在为我编写的一些 async 方法编写一些单元测试，并注意到 NUnit 建议将 async 测试标记为 void 或返回 Task。然后我尝试了一下，果然，它起作用了。这看起来真的很奇怪，因为 nunit 框架如何能够运行该方法并等待所有异步操作完成？如果它返回 Task，它可以等待任务，然后做它需要做的事情，但是如果它返回 void，它如何完成它呢？

于是我破解了源码，找到了。我可以在一个小样本中重现它，但我根本无法理解他们在做什么。我想我不太了解 SynchronizationContext 及其工作原理。这是代码:

class Program
{
    static void Main(string[] args)
    {
        RunVoidAsyncAndWait();

        Console.WriteLine("Press any key to continue. . .");
        Console.ReadKey(true);
    }

    private static void RunVoidAsyncAndWait()
    {
        var previousContext = SynchronizationContext.Current;
        var currentContext = new AsyncSynchronizationContext();
        SynchronizationContext.SetSynchronizationContext(currentContext);

        try
        {
            var myClass = new MyClass();
            var method = myClass.GetType().GetMethod("AsyncMethod");
            var result = method.Invoke(myClass, null);
            currentContext.WaitForPendingOperationsToComplete();
        }
        finally
        {
            SynchronizationContext.SetSynchronizationContext(previousContext);
        }
    }
}

public class MyClass
{
    public async void AsyncMethod()
    {
        var t = Task.Factory.StartNew(() =>
        {
            Thread.Sleep(1000);
            Console.WriteLine("Done sleeping!");
        });

        await t;
        Console.WriteLine("Done awaiting");
    }
}

public class AsyncSynchronizationContext : SynchronizationContext
{
    private int _operationCount;
    private readonly AsyncOperationQueue _operations = new AsyncOperationQueue();

    public override void Post(SendOrPostCallback d, object state)
    {
        _operations.Enqueue(new AsyncOperation(d, state));
    }

    public override void OperationStarted()
    {
        Interlocked.Increment(ref _operationCount);
        base.OperationStarted();
    }

    public override void OperationCompleted()
    {
        if (Interlocked.Decrement(ref _operationCount) == 0)
            _operations.MarkAsComplete();

        base.OperationCompleted();
    }

    public void WaitForPendingOperationsToComplete()
    {
        _operations.InvokeAll();
    }

    private class AsyncOperationQueue
    {
        private bool _run = true;
        private readonly Queue _operations = Queue.Synchronized(new Queue());
        private readonly AutoResetEvent _operationsAvailable = new AutoResetEvent(false);

        public void Enqueue(AsyncOperation asyncOperation)
        {
            _operations.Enqueue(asyncOperation);
            _operationsAvailable.Set();
        }

        public void MarkAsComplete()
        {
            _run = false;
            _operationsAvailable.Set();
        }

        public void InvokeAll()
        {
            while (_run)
            {
                InvokePendingOperations();
                _operationsAvailable.WaitOne();
            }

            InvokePendingOperations();
        }

        private void InvokePendingOperations()
        {
            while (_operations.Count > 0)
            {
                AsyncOperation operation = (AsyncOperation)_operations.Dequeue();
                operation.Invoke();
            }
        }
    }

    private class AsyncOperation
    {
        private readonly SendOrPostCallback _action;
        private readonly object _state;

        public AsyncOperation(SendOrPostCallback action, object state)
        {
            _action = action;
            _state = state;
        }

        public void Invoke()
        {
            _action(_state);
        }
    }
}

运行上述代码时，您会注意到 Done Sleeping 和 Done waiting 消息显示在 Press any key to continue 消息之前，这意味着异步方法正在以某种方式等待。

我的问题是，有人可以解释一下这里发生了什么吗？ SynchronizationContext 到底是什么(我知道它用于将工作从一个线程发布到另一个线程)，但我仍然对如何等待所有工作完成感到困惑。提前致谢!!

最佳答案

A SynchronizationContext允许将工作发布到由另一个线程(或线程池)处理的队列——通常 UI 框架的消息循环用于此。 async/await在您等待的任务完成后，该功能在内部使用当前同步上下文返回到正确的线程。

AsyncSynchronizationContext类实现自己的消息循环。发布到此上下文的工作被添加到队列中。 当你的程序调用 WaitForPendingOperationsToComplete(); ，该方法通过从队列中获取工作并执行它来运行消息循环。 如果在 Console.WriteLine("Done awaiting"); 上设置断点，你会看到它在 WaitForPendingOperationsToComplete() 内的主线程上运行方法。

另外，async/await功能调用 OperationStarted()/OperationCompleted()通知 SynchronizationContext 的方法每当 async void方法开始或结束执行。

AsyncSynchronizationContext使用这些通知来计算 async 的数量正在运行但尚未完成的方法。当此计数达到零时，WaitForPendingOperationsToComplete()方法停止运行消息循环，控制流返回给调用者。

要在调试器中查看此过程，请在 Post 中设置断点, OperationStarted和 OperationCompleted同步上下文的方法。然后单步执行 AsyncMethod调用:

• 何时AsyncMethod被调用，.NET 首先调用 OperationStarted()
  • 这设置了 _operationCount到 1。
• 然后是AsyncMethod的正文开始运行(并启动后台任务)
• 在 await声明，AsyncMethod交出控制权，因为任务尚未完成
• currentContext.WaitForPendingOperationsToComplete();被调用
• 队列中还没有可用的操作，因此主线程在 _operationsAvailable.WaitOne(); 进入休眠状态
• 在后台线程上:
  • 在某个时候任务结束休眠
  • 输出:Done sleeping!
  • 委托(delegate)完成执行，任务被标记为完成
  • Post()方法被调用，将表示 AsyncMethod 的剩余部分的延续加入队列
• 主线程唤醒，因为队列不再为空
• 消息循环运行延续，从而恢复执行 AsyncMethod
• 输出:Done awaiting
• AsyncMethod完成执行，导致 .NET 调用 OperationComplete()
  • _operationCount递减为 0，这标志着消息循环完成
• 控制权返回消息循环
• 消息循环结束，因为它被标记为完成，WaitForPendingOperationsToComplete返回给调用者
• 输出:Press any key to continue. . .

关于c# - nunit 如何成功等待 async void 方法完成？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/15031681/