Difference between returning and awaiting a Task in an async method [duplicate]

Answer 1

There are 2 practical differences:

1. The second option will not create the state machine mecanism that allows for async-await usage. That will have a minor positive effect on performance.
2. The exception handling would be a little different. When you mark a method as async any exceptions are stored in the returned task (both from the asynchronous part and the synchronous one) and thrown only when the task is awaited (or waited). When it's not async, the exceptions from the synchronous parts act just like in any other method.

My suggestion: Use the second one for the added performance boost but keep an eye out for exceptions and bugs.

---

An example that shows the difference:

public static async Task Test()
{
    Task pending = Task.FromResult(true);
    try
    {
        pending = SendAsync1();
    }
    catch (Exception)
    {
        Console.WriteLine("1-sync");
    }

    try
    {
        await pending;
    }
    catch (Exception)
    {
        Console.WriteLine("1-async");
    }

    pending = Task.FromResult(true);
    try
    {
        pending = SendAsync2();
    }
    catch (Exception)
    {
        Console.WriteLine("2-sync");
    }

    try
    {
        await pending;
    }
    catch (Exception)
    {
        Console.WriteLine("2-async");
    }
}

public static async Task SendAsync1()
{
    throw new Exception("Sync Exception");
    await Task.Delay(10);
}

public static Task SendAsync2()
{
    throw new Exception("Sync Exception");
    return Task.Delay(10);
}

Output:

1-async
2-sync

Answer 2

Your first method which awaits will cause the compiler to create a state machine, since once the await keyword is hit the method will return to the caller, and once the awaited part is completed it has to resume from the point where it left off.

But, since you aren't doing anything after awaiting (there is no continuation), there is no need for that state machine.

The second method is preferred in this case, and you can omit the async keyword from it since you are not awaiting anything

Answer 3

First of all, I don't think that the code in your example compiles. You need to remove the 'async' keyword from SendAsync2.

If you do that, then these methods can be used interchangeably, so no, there is no difference in this case. I would prefer the one without async/await.

However, there are cases where it would seem that there is no difference, but the difference lies in the details. Consider for example this code:

async Task<X> Get() 
{
     using (something) 
     {
          return await GetX();
     }
}

If you were to change this to:

Task<X> Get() 
{
    using (something)
    {
        return GetX(); 
    }
}

then the using block no longer protects the execution encapsulated in x, and something will be disposed earlier than it would in the first case. Important for example when something is a Entity Framework context.

The same goes for return await inside try blocks.