Правильный способ реализации методов, возвращающих Task <T>

Для простоты предположим, что у нас есть метод, который должен возвращать объект при выполнении тяжелой операции. Существует два способа реализации:

После изучения сгенерированного ИЛ есть две совершенно разные вещи:

Как вы можете видеть в первом случае логика проста, создается лямбда-функция, а затем вызывается вызов Task.Run и возвращается результат. Во втором примере создается экземпляр AsyncTaskMethodBuilder, и тогда задача фактически строится и возвращается. Поскольку я всегда ожидал, что метод foo будет называться как await Foo() на каком-то более высоком уровне, я всегда использовал первый пример. Тем не менее, я вижу последнее чаще. Итак, какой подход правильный? Какие плюсы и минусы у каждого есть?

Пример реального мира

Скажем, мы имеем UserStore, у которого есть метод Task<User> GetUserByNameAsync(string userName), который используется внутри веб-контроллера api, например:

Какая реализация Task<User> GetUserByNameAsync(string userName) была бы правильной?

Ответы

Ответ 1

Как вы можете видеть из IL, async/await создает конечный автомат (и дополнительный Task) даже в случае тривиальных хвостовых вызовов aync, т.е.

return await Task.Run(...);

Это приводит к ухудшению производительности за счет дополнительных инструкций и распределений. Итак, эмпирическое правило: если ваш метод заканчивается на await ... или return await ..., и это оператор один и только await, тогда в целом безопасно удалять ключевое слово async и прямо верните Task, который вы ожидаете.

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

В случае с return await ... есть скрытый заголовок. Если awaiter явно не сконфигурирован, чтобы не продолжать в захваченном контексте через ConfigureAwait(false), тогда внешний Task (тот, который был создан для машины состояния async) не может перейти в завершенное состояние до окончательной обратной передачи в SynchronizationContext (захвачен непосредственно перед await). Это не имеет никакой реальной цели, но все равно может привести к тупиковой ситуации, если по какой-то причине вы заблокируете внешнюю задачу (здесь подробное объяснение о том, что происходит в этом случае).

Ответ 2

Итак, какой подход правильный?

Ни.

Если у вас есть синхронная работа, тогда API должен быть синхронным:

public object Foo()
{
    // some heavy synchronous stuff.

    return new object();
}

Если вызывающий метод может блокировать свой поток (т.е. он представляет собой вызов ASP.NET или работает в потоке пула потоков), он просто вызывает его напрямую:

var result = Foo();

И если вызывающий поток не может заблокировать поток (т.е. он работает в потоке пользовательского интерфейса), тогда он может запустить Foo в пуле потоков:

var result = await Task.Run(() => Foo());

Как я описываю в своем блоге, Task.Run должен использоваться для вызова, а не для реализации.

Пример реального мира

(это совершенно другой сценарий)

Какая реализация Task GetUserByNameAsync (string userName) будет правильной?

Любой из них является приемлемым. Тот, у которого есть async и await, имеет некоторые дополнительные накладные расходы, но он не будет заметен во время выполнения (при условии, что вы await ing действительно делают I/O, что истинно в общем случае).

Обратите внимание, что если в методе есть другой код, то лучше с async и await. Это распространенная ошибка:

Task<string> MyFuncAsync()
{
  using (var client = new HttpClient())
    return client.GetStringAsync("http://www.example.com/");
}

В этом случае HttpClient устанавливается до завершения задачи.

Еще одна вещь, которую следует отметить, заключается в том, что исключения перед возвратом задачи различаются по-разному:

Task<string> MyFuncAsync(int id)
{
  ... // Something that throws InvalidOperationException
  return OtherFuncAsync();
}

Поскольку нет async, исключение не помещается в возвращаемую задачу; он бросается напрямую. Это может запутать вызывающий код, если он делает что-то более сложное, чем просто await выполнить задачу:

var task1 = MyFuncAsync(1); // Exception is thrown here.
var task2 = MyFuncAsync(2);
...
try
{
  await Task.WhenAll(task1, task2);
}
catch (InvalidOperationException)
{
  // Exception is not caught here. It was thrown at the first line.
}