When does 'await' immediately leave a method and when does it not?

Question

In programs utilizing async-await, my understanding is like this:

• an async method that IS NOT awaited will run in the background (?) and rest of the code will continue to execute before this non-awaited method finishes
• an async method that IS awaited will wait until the method finishes before moving on to the next lines of code

The application below was written by me to check if the above statements are correct.

using System;
using System.Threading.Tasks;

namespace ConsoleApp3
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            DoJob();

            var z = 3;

            Console.ReadLine();
        }

        static async Task DoJob()
        {
            var work1 = new WorkClass();
            var work2 = new WorkClass();

            while (true)
            {
                await work1.DoWork(500);
                await work2.DoWork(1500);
            }
        }
    }

    public class WorkClass
    {
        public async Task DoWork(int delayMs)
        {
            var x = 1;

            await Task.Delay(delayMs);

            var y = 2;
        }
    }
}

Here are some of my observations:

• The DoJob(); call is not awaited. However, the debugger shows me that the code inside of DoJob is being executed, just as if it was a normal non-async method.
• When code execution gets to await work1.DoWork(500);, I would think "OK, so maybe now the DoJob method will be left and var z = 3; will be executed? After all, 'await' should leave the method." In reality, it just goes into DoWork and doesn't leave DoJob - var z = 3; is still not executed.
• Finally, when execution reaches await Task.Delay(delayMs);, DoJob is left, and the var z = 3; is reached. After that, code after the Delay is executed.

The things that I don't understand:

• Why does await Task.Delay(delayMs); leave the DoJob method, but await work1.DoWork(500); does not?
• I see that DoJob is executing normally. I thought it would be done in the background (maybe by one of the thread pool threads?). Looks like it could block the thread if it was some long-running method, am I right?

Answer 1

Why does await Task.Delay(delayMs); leave the DoJob method, but await work1.DoWork(500); does not?

Because this code:

await work1.DoWork(500);

is the same as this code:

var task = work1.DoWork(500);
await task;

So your code is calling the method first, and then awaiting the returned task. It's common to talk about await as "awaiting method calls", but that's not what actually happens - technically, the method call is done first (synchronously), and then the returned task is awaited.

I see that DoJob is executing normally. I thought it would be done in the background (maybe by one of the thread pool threads?).

No; with true asynchronous operations, there is no thread that is blocked on that operation.

Looks like it could block the thread if it was some long-running method, am I right?

Yes.

my understanding is like this

I recommend reading my async intro for a better mental framework. In summary:

1. async enables the await keyword. It also generates a state machine that handles creating the Task return value and stuff like that.
2. await operates on an "awaitable" (usually a task). First, it checks to see if it's already complete; if it is, the async method continues executing synchronously.
3. If the awaitable is not already complete, then await (by default) captures its context and schedules the continuation of the async method to run on that context when the awaitable completes.

Answer 2

The compiler splits the code in an async method in chunks. 1 before the first await and 1 between each await and 1 after the last await.

The execution will return to the caller at the first non completed awaiter or the end of the method.

This method will only return a completed Task after fully executed:

async Task M1() => await Task.CompletedTask;

This method will only return an incomplete Task that will complete when the Task returned by Task.Dealy(1000) is completed:

async Task M2() => await Task.Delay(1000);

Here's a small example:

static async Task Main(string[] args)
{
    var t = TwoAwaits();
    Console.WriteLine("Execution returned to main");
    await t;
}
private static async Task TwoAwaits()
{
    Console.WriteLine("Before awaits");
    await Task.CompletedTask;
    Console.WriteLine("Between awaits #1");
    await Task.Delay(1000);
    Console.WriteLine("Between awaits #2");
    await Task.Delay(1000);
    Console.WriteLine("After awaits");
}
/*
Before awaits
Between awaits #1
Execution returned to main
Between awaits #2
After awaits
*/

Answer 3

Let's look at the four possibilities:

(1)

void Main()
{
    Console.WriteLine($"Main 0 - {Thread.CurrentThread.ManagedThreadId}");
    DoJob();
    Console.WriteLine($"Main 1 - {Thread.CurrentThread.ManagedThreadId}");
}

public static async Task DoJob()
{
    Console.WriteLine($"DoJob 0 - {Thread.CurrentThread.ManagedThreadId}");
    Thread.Sleep(2000);
    Console.WriteLine($"DoJob 1 - {Thread.CurrentThread.ManagedThreadId}");
}

This outputs:

Main 0 - 14
DoJob 0 - 14
DoJob 1 - 14
Main 1 - 14

It has a 2 second pause after DoJob 0.

(2)

async Task Main()
{
    Console.WriteLine($"Main 0 - {Thread.CurrentThread.ManagedThreadId}");
    await DoJob();
    Console.WriteLine($"Main 1 - {Thread.CurrentThread.ManagedThreadId}");
}

public static async Task DoJob()
{
    Console.WriteLine($"DoJob 0 - {Thread.CurrentThread.ManagedThreadId}");
    Thread.Sleep(2000);
    Console.WriteLine($"DoJob 1 - {Thread.CurrentThread.ManagedThreadId}");
}

Again this outputs:

Main 0 - 14
DoJob 0 - 14
DoJob 1 - 14
Main 1 - 14

(3)

async Task Main()
{
    Console.WriteLine($"Main 0 - {Thread.CurrentThread.ManagedThreadId}");
    await DoJob();
    Console.WriteLine($"Main 1 - {Thread.CurrentThread.ManagedThreadId}");
}

public static Task DoJob()
{
    return Task.Run(() =>
    {
        Console.WriteLine($"DoJob 0 - {Thread.CurrentThread.ManagedThreadId}");
        Thread.Sleep(2000);
        Console.WriteLine($"DoJob 1 - {Thread.CurrentThread.ManagedThreadId}");
    });
}

This has different output because it has changed thread:

Main 0 - 15
DoJob 0 - 13
DoJob 1 - 13
Main 1 - 13

And finally:

async Task Main()
{
    Console.WriteLine($"Main 0 - {Thread.CurrentThread.ManagedThreadId}");
    DoJob();
    Console.WriteLine($"Main 1 - {Thread.CurrentThread.ManagedThreadId}");
}

public static Task DoJob()
{
    return Task.Run(() =>
    {
        Console.WriteLine($"DoJob 0 - {Thread.CurrentThread.ManagedThreadId}");
        Thread.Sleep(2000);
        Console.WriteLine($"DoJob 1 - {Thread.CurrentThread.ManagedThreadId}");
    });
}

This has a different output again:

Main 0 - 13
Main 1 - 13
DoJob 0 - 12
DoJob 1 - 12

In this last case it is not waiting for DoJob because DoJob is running on a different thread.

So if you follow the logic here the issue is that async/await doesn't create (or use) a different thread. The method called must do that.

Answer 4

Before Async & Await, there was two type of methods. Those who returned the result directly, and those who received a callback function as a parameter. On the latter, the method was invoked in the same thread syncronously and returned no value, and later, on the same or different thread your callback function would have been called with the result. Historically all I/O (disk, network, even memory) worked with callbacks (actually: interrupts) but medium to high level languages like C# would mask all that internally so end users don't need to learn/write low level code.

This worked pretty well up to a point, except this optimization wasted some physical resources. For example Node.js outperformed several other languages/server platforms by their limitation that forces the developers to use the callback model instead of the 'managed' mode.

This pushed C# and other languages to go back to the callback model, but the code readability really suffered (code callback spaguetti). So Async and Await was introduced.

Async and await let's you write in the 'callback model' with 'managed' syntax. All callbacks are handled by the compiler.

Each time you write 'await' in an async method, your method is actually split into two methods connected by a callback.

Now, you can write an async method that does regular sync code, without awaits, nor thread switch or I/O. That 'async' method will actually run synchronously. So, it is actually the same to await method1() or call without await. Why? because your async call is not awaiting anything, so your async code is still one piece of continous code.

If inside your method you await one, two or more different methods, then your method will be split into one, two or more pieces. And only the first piece will be guaranteed to be run synchronously. All the other pieces will run on other thread depending on the code that you are awaiting.

TL;DR;

• Async/Await method is does not guarantees multi-threading or parallel processing. That will actually depend on the payload (the called async method). For example, http downloads will tipically be paralellized if you manage your awaits because those are functions that are mostly waiters of an external response. On the other side, heavy CPU processing, like compressing a file, will require other form of cpu/thread management not provided by async/await.

• If you do not await an async method, your code will surely run synchronously up to the first await of the called method, given it has one. But later on, it may or not run sync.

Answer 5

why does await Task.Delay(delayMs); leave the DoJob method, but await work1.DoWork(500); does not?

Because, up and until there is an actual asynchronous call, it's still in the same context. If DoWork was just:

public async Task DoWork(int delayMs)
{
    var x = 1;
    var y = 2;

    return Task.CompletedTask;
}

there would be no need for a continuation and hence, you would debug all the way without "jumping" back to the orignal await call.

Answer 6

Here is how your application could be remodeled if you were forced to avoid async/await for some reason. See how complex it gets to replicate the logic inside the loop. Async/await is really a gift from the heavens!

using System;
using System.Threading.Tasks;

namespace ConsoleApp3
{
    class Program
    {
        static Task Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            DoJob();

            var z = 3;

            Console.ReadLine();
            return Task.CompletedTask;
        }

        static Task DoJob()
        {
            var work1 = new WorkClass();
            var work2 = new WorkClass();

            var tcs = new TaskCompletionSource<bool>();
            Loop();
            return tcs.Task;

            void Loop()
            {
                work1.DoWork(500).ContinueWith(t1 =>
                {
                    if (t1.IsFaulted) { tcs.SetException(t1.Exception); return; }
                    work2.DoWork(1500).ContinueWith(t2 =>
                    {
                        if (t2.IsFaulted) { tcs.SetException(t2.Exception); return; }
                        if (true) { Loop(); } else { tcs.SetResult(true); }
                        // The 'if (true)' corresponds to the 'while (true)'
                        // of the original code.
                    });
                });
            }
        }
    }

    public class WorkClass
    {
        public Task DoWork(int delayMs)
        {
            var x = 1;

            int y;

            return Task.Delay(delayMs).ContinueWith(t =>
            {
                if (t.IsFaulted) throw t.Exception;
                y = 2;
            });
        }
    }
}