Pass a lambda or an async lambda for execution? Are there tradeoffs?

Question

I'm trying to understand the consequences of two approaches to passing a lambda into an async method that executes the lambda. The below example distills the two approaches. In the first approach, the lambda itself async whereas it isn't in the second approach.

While this is a contrived example, I'm trying to determine if either approach is more "correct", handles corner cases better (e.g. if the lambda throws), has significantly better performance, and so on. Are these approaches, from the caller's perspective, functionally equivalent?

class Program
{
    static async Task Main(string[] args)
    {
        var result1 = await ExecuteFuncAsync(
            async () =>
            {
                var funcResult = await Task.FromResult(false);

                return funcResult;
            });

        var result2 = await ExecuteFuncAsync(
            () =>
            {
                var funcResult = Task.FromResult(false);

                return funcResult;
            });
    }

    private static async Task<bool> ExecuteFuncAsync(Func<Task<bool>> func)
    {
        return await func();
    }
}

Answer 1

It depends on the context. I would argue that there is no major difference between the two (in the provided sample, in general - see "Eliding Async and Await" by Stephen Cleary).

Though there is a third option which should be considered in cases when the wrapped func is a synchronous one:

var result2 = ExecuteFuncAsync(() => Task.Run(() =>
{
    var funcResult = true;
    return funcResult;
}));

Or for some mainly testing/experimentation scenarios:

var result2 = await ExecuteFuncAsync(async () =>
{
    await Task.Yield();
    var funcResult = true;
    return funcResult;
});

The difference being that async function returns control to the caller at the first await but only if awaited task is not completed yet. Consider the following snippet:

Console.WriteLine("First before");
var first = ExecuteFuncAsync(
    async () =>
    {
        var funcResult = await Task.FromResult(false);
        return funcResult;
    });
Console.WriteLine("First before await");
await first;
Console.WriteLine("First after await");
Console.WriteLine();
Console.WriteLine("Second before");
var second = ExecuteFuncAsync(() =>
    {
        var funcResult = Task.FromResult(false);
        return funcResult;
    });
Console.WriteLine("Second before await");
await second;
Console.WriteLine("Second after await");
Console.WriteLine();
Console.WriteLine("Third before");
var third= ExecuteFuncAsync(async () =>
    {
        await Task.Yield();
        return true;
    });
Console.WriteLine("Third before await");
await third;
Console.WriteLine("Third after await");

static async Task<bool> ExecuteFuncAsync(Func<Task<bool>> func)
{
    var t  = func();
    Console.WriteLine("Inner Before await");
    await t;
    Console.WriteLine("Inner After await");
    return true;
}

Which produces the following output:

First before
Inner Before await
Inner After await
First before await
First after await

Second before
Inner Before await
Inner After await
Second before await
Second after await

Third before
Inner Before await
Third before await
Inner After await
Third after await

See that for the fist two cases the outer before and after await happen only after both inner before and after, while third option has "correct" order of output. This can be a bid deal.in some cases if the inner function is a long-running one and caller relies on the asynchronous behaviour.