Difference between awaiting straight away or awaiting later on

Question

I cannot find any information on the actually difference.

So I have always done the following:

public async Task<int> DoSomethingAsync()
{
    DoSomethingElse()
    var result = await GetValueAsync();
    var intValue = DoAnotherThing(result);
    return intValue;
}

await the call and then use it straight after, but I have seen recently a few posts where people are doing the following:

public async Task<int> DoSomethingAsync()
{    
    var task = GetValueAsync();
    DoSomethingElse()
    var result = await task;
    var intValue = DoAnotherThing(result);
    return intValue;
}

So does this mean that the method GetValueAsync is starting it's execution and then we await the result of it later? Or does it mean that it's executing synchronously but it's still awaitable?

Answer 1

Damien_The_Unbeliever is right when he said that it depends on the implementation.

class Program
{
    public static int DoAnotherThing(string value)
    {
        return int.Parse(value);
    }

    public static async Task<string> GetValueAsync()
    {
        await Task.Delay(5000);
        return "12";
    }

    public static void DoSomethingElse()
    {
        Thread.Sleep(5000);
    }

    public static async Task<int> DoSomethingAsyncA()
    {
        DoSomethingElse();
        var result = await GetValueAsync();
        var intValue = DoAnotherThing(result);
        return intValue;
    }

    public static async Task<int> DoSomethingAsyncB()
    {
        var task = GetValueAsync();
        DoSomethingElse();
        var result = await task;
        var intValue = DoAnotherThing(result);
        return intValue;
    }

    public static void Measure(Action act)
    {
        var sw = new Stopwatch();

        sw.Start();

        act();

        sw.Stop();

        Console.WriteLine(sw.Elapsed);
    }

    static void Main(string[] args)
    {
        Measure(() => DoSomethingAsyncA().Wait());
        Measure(() => DoSomethingAsyncB().Wait());

        Console.ReadLine();
    }
}

In this case DoSomethingAsyncB will take ~5 seconds, where DoSomethingAsyncA will take ~10. However if your GetValueAsync returns a value computation of which was started somewhere else, then there will be no difference.

UPDATE I corrected the mistake in the answer. And here is the output from my machine:

  00:00:10:0161446
  00:00:05:0032000

Answer 2

In this

public async Task<int> DoSomethingAsync()
{
    DoSomethingElse()
    var result = await GetValueAsync();
    var intValue = DoAnotherThing(result);
    return intValue;
}

It means that when you await the GetValueAsync's result as soon as possible without executing any other code.

The code below means :

public async Task<int> DoSomethingAsync()
{    
    var task = GetValueAsync();
    DoSomethingElse()
    var result = await task;
    var intValue = DoAnotherThing(result);
    return intValue;
}

You call GetValueAsync and do DoSomethingElse while waiting GetValueAsync to finish it and then when it is finished it continues executing DoAnotherThing

Answer 3

Quite often people think that async-await is done by several threads. Usually this isn't not the case. Unless you start other threads, all code is performed by the same thread. Checking the ThreadId of the current thread will show you this.

In an interview Eric Lippert explained async-await in a restaurant metaphor. Search somewhere in the middle for async await.

He explains that if a cook toasts some bread he can wait until the bread is toasted or start doing something else and come back later to see if the toaster finished toasting.

The same happens in your second DoSomethingAsync. When writing date to a disk, your thread delivers the data to the disk writer. Writing to disks is a relatively slow process. The thread doesn't wait for the date to be written, instead it starts doing something else. When it finished doing something else, the thread awaits until the disk write has finished writing to disk.

This is only useful if the disk write can continue writing while your thread is doing something else. Therefore you usually see async functions when hardware is involved, or processes that start other threads to do some work. If the async function has to do some time consuming calculations it is not useful to make the function async, unless it starts another thread to do the calculations. Even then it is questionable whether this should be done inside an async function or whether the caller should have the freedom to decide whether to let his own thread do the calculations or start a different thread to do this.

Another article that helped me to understand async-await by Stephen Cleary, a great contributor to this site (thanks again Stephen!)