async / await - когда вернуть Task void void?

По каким сценариям можно использовать

public async Task AsyncMethod(int num)

вместо

public async void AsyncMethod(int num)

Единственный сценарий, который я могу придумать, - это если вам нужна задача, чтобы отслеживать ее прогресс.

Кроме того, в следующем методе ненужны ли ключевые слова async и await?

public static async void AsyncMethod2(int num)
{
    await Task.Factory.StartNew(() => Thread.Sleep(num));
}

1) Обычно вы хотите вернуть Task. Основное исключение должно быть, когда вам нужно иметь voidтип возвращаемого значения (для событий). Если нет никаких причин, чтобы запретить вызывающему абоненту выполнять awaitвашу задачу, зачем это запрещать?

2) asyncметоды, которые возвращают, voidявляются специальными в другом аспекте: они представляют асинхронные операции верхнего уровня и имеют дополнительные правила, которые вступают в действие, когда ваша задача возвращает исключение. Проще всего показать разницу с помощью примера:

static async void f()
{
    await h();
}

static async Task g()
{
    await h();
}

static async Task h()
{
    throw new NotImplementedException();
}

private void button1_Click(object sender, EventArgs e)
{
    f();
}

private void button2_Click(object sender, EventArgs e)
{
    g();
}

private void button3_Click(object sender, EventArgs e)
{
    GC.Collect();
}

fисключение всегда "соблюдается". Исключение, которое оставляет асинхронный метод верхнего уровня, просто обрабатывается как любое другое необработанное исключение. gисключение никогда не наблюдается. Когда сборщик мусора приходит для очистки задачи, он видит, что задача вызвала исключение, и никто не обработал исключение. Когда это происходит, TaskScheduler.UnobservedTaskExceptionобработчик запускается. Никогда не позволяй этому случиться. Чтобы использовать ваш пример,

public static async void AsyncMethod2(int num)
{
    await Task.Factory.StartNew(() => Thread.Sleep(num));
}

Да, использовать asyncиawait здесь, они гарантируют, что ваш метод все еще работает правильно, если выброшено исключение.

Для получения дополнительной информации см .: http://msdn.microsoft.com/en-us/magazine/jj991977.aspx

Я сталкивалась с этим очень полезно статей о asyncи voidнаписала Жером Лавану: https://jaylee.org/archive/2012/07/08/c-sharp-async-tips-and-tricks-part-2-async-void .html

Суть в том, что это async+voidможет привести к сбою системы и обычно должно использоваться только в обработчиках событий на стороне пользовательского интерфейса.

Причиной этого является контекст синхронизации, используемый AsyncVoidMethodBuilder, который в этом примере отсутствует. При отсутствии окружающего контекста синхронизации любое исключение, которое не обрабатывается телом асинхронного пустого метода, повторно вызывается в ThreadPool. Хотя, по-видимому, нет другого логического места, где можно было бы генерировать такого рода необработанное исключение, неудачный эффект заключается в том, что процесс завершается, потому что необработанные исключения в ThreadPool эффективно завершают процесс начиная с .NET 2.0. Вы можете перехватить все необработанные исключения с помощью события AppDomain.UnhandledException, но нет способа восстановить процесс из этого события.

При написании обработчиков событий пользовательского интерфейса асинхронные пустые методы почему-то безболезненны, поскольку исключения обрабатываются так же, как и в неасинхронных методах; они брошены на Диспетчер. Существует возможность восстановления после таких исключений, в большинстве случаев это более чем правильно. Однако вне обработчиков событий пользовательского интерфейса асинхронные методы void опасны для использования и их может быть не так просто найти.

Я получил четкое представление из этого заявления.

1. Асинхронные методы void имеют различную семантику обработки ошибок. Когда исключение выбрасывается из метода асинхронной задачи или асинхронной задачи, это исключение захватывается и помещается в объект задачи. При использовании асинхронных void-методов объект Task отсутствует, поэтому любые исключения, выбрасываемые из асинхронного void-метода, будут вызываться непосредственно в SynchronizationContext (SynchronizationContext представляет код местоположения «где» может выполняться.), Который был активен, когда асинхронный void-метод начал

Исключения из асинхронного метода Void нельзя обнаружить с помощью Catch

private async void ThrowExceptionAsync()
{
  throw new InvalidOperationException();
}
public void AsyncVoidExceptions_CannotBeCaughtByCatch()
{
  try
  {
    ThrowExceptionAsync();
  }
  catch (Exception)
  {
    // The exception is never caught here!
    throw;
  }
}

Эти исключения можно наблюдать с помощью AppDomain.UnhandledException или аналогичного события перехвата для приложений GUI / ASP.NET, но использование этих событий для регулярной обработки исключений является рецептом для невозможности обслуживания (он приводит к сбою приложения).

2. Асинхронные методы void имеют различную семантику создания. Асинхронные методы, возвращающие Task или Task, могут быть легко составлены с использованием await, Task.WhenAny, Task.WhenAll и так далее. Асинхронные методы, возвращающие void, не обеспечивают простой способ уведомить вызывающий код о том, что они завершили. Легко запустить несколько асинхронных пустых методов, но нелегко определить, когда они закончили. Асинхронные методы void будут уведомлять свой SynchronizationContext при запуске и завершении, но пользовательский SynchronizationContext является сложным решением для обычного кода приложения.

3. Метод Async Void полезен при использовании синхронного обработчика событий, потому что они вызывают свои исключения непосредственно в SynchronizationContext, что аналогично тому, как ведут себя синхронные обработчики событий.

Для получения более подробной информации перейдите по этой ссылке https://msdn.microsoft.com/en-us/magazine/jj991977.aspx

Проблема с вызовом async void заключается в том, что вы даже не получаете задачу обратно, у вас нет возможности узнать, когда задача функции была выполнена (см. Https://blogs.msdn.microsoft.com/oldnewthing/20170720-00/ ? p = 96655 )

Вот три способа вызова асинхронной функции:

async Task<T> SomethingAsync() { ... return t; }
async Task SomethingAsync() { ... }
async void SomethingAsync() { ... }

Во всех случаях функция превращается в цепочку задач. Разница в том, что возвращает функция.

В первом случае функция возвращает задачу, которая в конечном итоге производит t.

Во втором случае функция возвращает задачу, у которой нет продукта, но вы все еще можете ждать ее, чтобы узнать, когда она завершится.

Третий случай - неприятный. Третий случай похож на второй, за исключением того, что вы даже не получаете задание обратно. У вас нет возможности узнать, когда задача функции выполнена.

Случай асинхронной пустоты - это «запустить и забыть»: вы запускаете цепочку задач, но вам все равно, когда она закончится. Когда функция возвращается, все, что вы знаете, это то, что все до первого ожидания выполнено. Все после первого ожидания будет выполняться в какой-то неопределенной точке в будущем, к которой у вас нет доступа.

Я думаю, что вы также можете использовать async voidдля запуска фоновых операций, если вы будете осторожны, чтобы ловить исключения. Мысли?

class Program {

    static bool isFinished = false;

    static void Main(string[] args) {

        // Kick off the background operation and don't care about when it completes
        BackgroundWork();

        Console.WriteLine("Press enter when you're ready to stop the background operation.");
        Console.ReadLine();
        isFinished = true;
    }

    // Using async void to kickoff a background operation that nobody wants to be notified about when it completes.
    static async void BackgroundWork() {
        // It's important to catch exceptions so we don't crash the appliation.
        try {
            // This operation will end after ten interations or when the app closes. Whichever happens first.
            for (var count = 1; count <= 10 && !isFinished; count++) {
                await Task.Delay(1000);
                Console.WriteLine($"{count} seconds of work elapsed.");
            }
            Console.WriteLine("Background operation came to an end.");
        } catch (Exception x) {
            Console.WriteLine("Caught exception:");
            Console.WriteLine(x.ToString());
        }
    }
}

Мой ответ прост, вы не можете ждать пустого метода

Error   CS4008  Cannot await 'void' TestAsync   e:\test\TestAsync\TestAsyncProgram.cs

Поэтому, если метод асинхронный, лучше быть ожидаемым, потому что вы можете потерять преимущество асинхронности.

Согласно документации Microsoft , НИКОГДА не следует использоватьasync void

Не делайте этого: в следующем примере используется async voidвыполнение HTTP-запроса при достижении первого ожидания:

• Что ВСЕГДА плохая практика в приложениях ASP.NET Core.

• Получает доступ к HttpResponse после завершения HTTP-запроса.

• Сбой процесса.