What are differences between the 3 calls for async Func> in c#?

Question

What are differences between the 3 calls inside method WhatDifferences?

Here is test code:

async Task WhatDifferences(Context context)
{
    await ActionAsync(context, async x => await IsOddAsync(x).ConfigureAwait(false));
    await ActionAsync(context, x => IsOddAsync(x));
    await ActionAsync(context, IsOddAsync);
}

async Task<T> ActionAsync<T>(Context context, Func<Context, Task<T>> action)
{
    return await action(context).ConfigureAwait(false);
}

async Task<bool> IsOddAsync(Context context)
{
    return await Task.Run(() => context.Count++ % 2 == 1).ConfigureAwait(false);
}

class Context
{
    public int Count { get; set; }
}

I'm trying to decide which one to use in my codebase and based on my knowledge all 3 behave the same.

The question is different with What's the method signature for passing an async delegate?

You may know my concern if I show more logic

async Task<T> ActionAsync<T>(Context context, Func<Context, Task<T>> action)
{
    using (var transaction = new TransactionScope())
    {
        //do some async logic before action
        var result = await action(context).ConfigureAwait(false);
        //do other async validation logic after action
        return result;
    }
}

Answer 1

I'm trying to decide which one to use in my codebase and based on my knowledge all 3 behave the same.

In this specific instance, this is essentially true.

This one creates a delegate that refers to the IsOddAsync method:

await ActionAsync(context, IsOddAsync);

This one creates a method for the lambda expression and the delegate refers to that compiler-generated method:

await ActionAsync(context, x => IsOddAsync(x));

And this one does the same, but for an asynchronous lambda, so the compiler-generated method also has an async state machine:

await ActionAsync(context, async x => await IsOddAsync(x).ConfigureAwait(false));

In general, your question boils down to two questions:

1. Should I use method groups instead of lambdas? Yes, you should. There's no disadvantage to doing so, and it's a tiny bit more efficient, shorter code, without any impact on maintainability.
2. Should I elide async/await or keep the keywords in? This one is more nuanced.

Eliding async in this particular case is fine, because all the async lambda is doing is calling a single method and passing its parameter. There's no possibility of exceptions being thrown from the lambda before or after the call to IsOddAsync.

However, if your lambda is more complex - doing operations on x before passing it to IsOddAsync, or doing operations on the result, or using a using block, then you'd want to keep the async/await keywords for maximum maintainability. More information here.

Answer 2

await vs return Task

The difference between:

await ActionAsync(context, async x => await IsOddAsync(x).ConfigureAwait(false));
await ActionAsync(context, x => IsOddAsync(x));

In some cases you don't need the await (and also not the async of course)

Methods that perform asynchronous operations don't need to use await if:

• There is only one asynchronous call inside the method
• The asynchronous call is at the end of the method
• Catching/handling exception that may happen within the Task is not necessary

See Returning a Task without await.

In that case you could return the Task intermediately.

Please note there is a small difference in behavior - depending on the implementation of IsOddAsync:

Important: Returning the Task instead of awaiting it, changes the exception behavior of the method, as it won't throw the exception inside the method which starts the task but in the method which awaits it.

As Gabriel Luci noted, with the current implementation of IsOddAsync (one call and an await), there is no difference in behavior.

x => IsOddAsync(x) vs IsOddAsync

The difference between

await ActionAsync(context, x => IsOddAsync(x));
await ActionAsync(context, IsOddAsync);

In the first one your are creating an anonymous (lambda) method with the parameter x. As IsOddAsync has also one parameter (with the same type), there is no need for the lambda method.

Please note you need the lambda if IsOddAsync has other parameters, e.g. and 2nd parameter, then you need the lambda. Example:

await ActionAsync(context, x => IsOddAsync(x, "mySecondParameter"));

In this case there is no difference in behavior, except the callstack when an exception in thrown inside.