Jak nunit pomyślnie czeka na zakończenie metody async void?

Podczas używania async/await W C#, ogólną zasadą jest unikanie async void, ponieważ jest to prawie ogień i zapominanie, a raczej Task powinno być używane, jeśli nie jest wysyłana żadna wartość zwracana z metody. To ma sens. Dziwne jest jednak to, że na początku tygodnia pisałem testy jednostkowe dla kilku metod async, które napisałem, i zauważyłem, że NUnit zasugerował, aby oznaczyć async testy jako void lub zwracając Task. Potem spróbowałem i na pewno zadziałało. To wydawało się naprawdę dziwne, jak nunit framework czy można uruchomić metodę i czekać na zakończenie wszystkich operacji asynchronicznych? Jeśli zwróci zadanie, może po prostu poczekać na zadanie, a następnie zrobić to, co musi zrobić, ale jak może to zrobić, jeśli zwróci void?

Więc złamałem kod źródłowy i znalazłem go. Mogę to odtworzyć w małej próbce, ale po prostu nie mogę zrozumieć, co robią. Chyba za mało wiem o SynchronizationContext i jak to działa. Oto kod:

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

Kiedy uruchamiając powyższy kod, zauważysz, że wiadomości Done Sleeping i Done waiting pojawiają się przed naciśnij dowolny klawisz, aby kontynuować wiadomość, co oznacza, że metoda asynchroniczna jest w jakiś sposób czekana.