What's the difference between the following Func> async delegate approaches?

Question

If I have the following method:

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

What is the difference between the following two usages:

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

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

Both compile, both work and there are no C# warnings.

What's the difference (if any)? Will both methods run true async if awaited by the caller?

Answer 1

There is no functional difference between the two. The only difference is if the Task from SomeActionAsync is returned directly or if it is awaited. Stephen Cleary has a good blog post about this, and recommends the second aproach for this trivial case.

The reason why the first approach is available is that you could have a non-trivial lambda expression like this:

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

So the difference is the same as the difference between a method whith this signature public async Task<int> MyMethod and this one public Task<int> MyMethod

Answer 2

Short Answer

MethodOneAsync() is truly Async, and shall be used, but MethodTwoAsync() is not truly Async, as it invokes Thread pool thread

Long Answer

For the purpose of testing and running I have simplified your code as follows:

Execution from the Main method of Linqpad as follows:

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

resultTask.Result.Dump();

Actual Code

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

Now I reviewed the IL generated between the two calls and following is the most important difference:

First call with Async and Await inside DoSomethingAsync has following 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      

Second one without Async and Await has the following code:

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

Beside this the first one has the complete state machine code for extra async await call, which is expected.

Important points:

1. For Async method call use async () => await SomeActionAsync(), as this is true Async execution and works on IO completion ports
2. In other case it invokes a Threadpool thread for the Async method execution, which is not good for Asynchronous execution

I can paste the complete IL if required to understand the difference, but best is you evaluate the same in the Visual studio or LinqPad to understand the nuances

Answer 3

Firstly, your example doesn't make sense, you're either returning something, or not, returning the results of the awaited function without a return type would be a compiler error.

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

Secondly, this has nothing to do with "true" async as that would be an implementation detail which is not shown

Thirdly, the only difference between either of the hypothetical examples

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

and

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

Given the definition of DoSomethingAsync, in the first example the compiler will create an extra IAsyncStateMachine implementation, instead of just forwarding the Task. I.e More compiled code, more IL, more instructions, and in this example seemingly redundant.

There are is a small caveat with exceptions when eliding tasks, however because this is just a simple pass through there is no other code which will throw, ergo the extra state-machine or try catch and Task.FromException is not needed.

The real appreciable differences would come if your signature was actually an Action instead of Func<Task> which would create an async void given an async lambda, however this is not case in your question.

Answer 4

Async/await construct inserts some infrastructure code which is only useful if there is some code after the "await". Otherwise it essentially does nothing. Your code is equivalent to

public Task MethodThreeAsync()
{
    return DoSomethingAsync(() => SomeActionAsync());
}

All of the three methods are "true async".