При использовании async/await
в С# общее правило состоит в том, чтобы избегать async void
, поскольку это в значительной степени является огнем и забывается, вместо этого следует использовать Task
, если из метода не возвращено возвращаемое значение. Имеет смысл. Странно, однако, что на той неделе, когда я писал несколько модульных тестов для нескольких методов async
, которые я написал, и заметил, что NUnit предложил пометить теги async
как либо void
, либо вернуть Task
. Затем я попробовал, и, конечно же, это сработало. Это выглядело действительно странным, как можно было бы реализовать структуру nunit для запуска метода и дождаться завершения всех асинхронных операций? Если он возвращает "Задача", он может просто ждать задания, а затем делать то, что ему нужно, но как он может его отключить, если он вернет пустоту?
Итак, я взломал исходный код и нашел его. Я могу воспроизвести его в небольшом экземпляре, но я просто не могу понять, что они делают. Наверное, я недостаточно разбираюсь в 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, ожидающие сообщения, появляются до нажатия любой клавиши для продолжения сообщения, что означает, что метод async каким-то образом ждет.
Мой вопрос: может кто-то может объяснить, что здесь происходит? Что такое SynchronizationContext
(я знаю, что он использовался для публикации работы из одного потока в другой), но я все еще смущен тем, как мы можем ждать выполнения всей работы. Спасибо заранее!