Блог

Если у меня есть следующий метод:

 public async Task<T> DoSomethingAsync<T>(Func<Task<T>> action)
{
   // bunch of async code..then "await action()"
}
  

В чем разница между следующими двумя способами использования:

 public async Task MethodOneAsync()
{
   return await DoSomethingAsync(async () => await SomeActionAsync());
}

public async Task MethodTwoAsync()
{
   return await DoSomethingAsync(() => SomeActionAsync());
}
  

Оба компилируются, оба работают, и предупреждений C # нет.

В чем разница (если есть)? Будут ли оба метода выполняться асинхронно, если их ожидает вызывающий?

Между ними нет функциональной разницы. Единственная разница заключается Task в том, возвращается ли from SomeActionAsync напрямую или если оно ожидается. У Стивена Клири есть хороший пост в блоге об этом, и он рекомендует второй подход для этого тривиального случая.

Причина, по которой доступен первый подход, заключается в том, что у вас может быть нетривиальное лямбда-выражение, подобное этому:

 public async Task MethodOneAsync()
{
    return await DoSomethingAsync(async () => {
        var i = _isItSunday ? 42 : 11;
        var someResult = await SomeActionAsync(i);
        return await AnotherActionAsync(someResult*i);
    });
}
  

Таким образом, разница такая же, как разница между методом с этой сигнатурой public async Task<int> MyMethod и этим public Task<int> MyMethod

Короткий ответ

MethodOneAsync() действительно асинхронный и должен использоваться, но MethodTwoAsync() не является действительно асинхронным, поскольку он вызывает поток пула потоков

Длинный ответ

С целью тестирования и запуска я упростил ваш код следующим образом:

Выполнение из основного метода Linqpad следующим образом:

 var resultTask = MethodOneAsync(); // Comment one the methods

resultTask.Result.Dump();
  

Фактический код

 public async Task<int> DoSomethingAsync(Func<Task<int>> action)
{
    return await Task.FromResult<int>(3);
}

public async Task<int> MethodOneAsync()
{
    await Task.Delay(10);
    return await DoSomethingAsync(async () => await Task.FromResult<int>(3));
}

public async Task<int> MethodOneAsync()
{
    await Task.Delay(10);
    return await DoSomethingAsync(() => Task.FromResult<int>(3));
}
  

Теперь я рассмотрел разницу IL generated между двумя вызовами, и следующее является наиболее важным отличием:

Первый вызов с Async and Await inside DoSomethingAsync имеет следующий IL:

 <>c.<MethodOneAsync>b__2_0:
IL_0000:  newobj      UserQuery <>c <<MethodOneAsync>b__2_0>d..ctor
IL_0005:  stloc.0     
IL_0006:  ldloc.0     
IL_0007:  ldarg.0     
IL_0008:  stfld       UserQuery <>c <<MethodOneAsync>b__2_0>d.<>4__this
IL_000D:  ldloc.0     
IL_000E:  call        System.Runtime.CompilerServices.AsyncTaskMethodBuilder<System.Int32>.Create
IL_0013:  stfld       UserQuery <>c <<MethodOneAsync>b__2_0>d.<>t__builder
IL_0018:  ldloc.0     
IL_0019:  ldc.i4.m1   
IL_001A:  stfld       UserQuery <>c <<MethodOneAsync>b__2_0>d.<>1__state
IL_001F:  ldloc.0     
IL_0020:  ldfld       UserQuery <>c <<MethodOneAsync>b__2_0>d.<>t__builder
IL_0025:  stloc.1     
IL_0026:  ldloca.s    01 
IL_0028:  ldloca.s    00 
IL_002A:  call        System.Runtime.CompilerServices.AsyncTaskMethodBuilder<System.Int32>.Start<<<MethodOneAsync>b__2_0>d>
IL_002F:  ldloc.0     
IL_0030:  ldflda      UserQuery <>c <<MethodOneAsync>b__2_0>d.<>t__builder
IL_0035:  call        System.Runtime.CompilerServices.AsyncTaskMethodBuilder<System.Int32>.get_Task
IL_003A:  ret      
  

Второй без Async and Await имеет следующий код:

 <>c.<MethodOneAsync>b__2_0:
IL_0000:  ldc.i4.3    
IL_0001:  call        System.Threading.Tasks.Task.FromResult<Int32>
IL_0006:  ret      
  

Помимо этого, первый имеет полный конечный машинный код для дополнительного async await вызова, который ожидается.

Важные моменты:

1. Для использования асинхронного вызова метода async () => await SomeActionAsync() , поскольку это истинное асинхронное выполнение и работает на портах завершения ввода-вывода
2. В другом случае он вызывает Threadpool поток для выполнения асинхронного метода, что не подходит для асинхронного выполнения

Я могу вставить полный IL, если требуется, чтобы понять разницу, но лучше всего оценить то же самое в Visual studio или LINQPad, чтобы понять нюансы

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

 public async Task MethodOneAsync()
{
    return await DoSomethingAsync(() => SomeActionAsync());
}
  

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

В-третьих, единственное различие между любым из гипотетических примеров

 await DoSomethingAsync(async () => await SomeActionAsync());
  

и

 await DoSomethingAsync(() =>  SomeActionAsync()); 
  

Учитывая определение DoSomethingAsync , в первом примере компилятор создаст дополнительную IAsyncStateMachine реализацию вместо простой пересылки Task . Т.е. Больше скомпилированного кода, больше IL, больше инструкций, и в этом примере, по-видимому, избыточно.

Однако, поскольку это всего лишь простой проход, нет другого кода, который будет выдавать, следовательно, дополнительный конечный автомат или try catch и Task.FromException не нужен.