Is my following understanding of the Context in terms of async await correct?

Question

I was going through https://blog.stephencleary.com/2012/02/async-and-await.html and according to the author the Context is either of the following:

1. If you’re on a UI thread, then it’s a UI context.

2. If you’re responding to an ASP.NET request, then it’s an ASP.NET request context.

3. Otherwise, it’s usually a thread pool context.

So in a console application with the following code:

public static void Main()
{
    Thread.CurrentThread.Name = "MainThread";
    var task = SomeAsync();
    string result = task.Result;
    Console.WriteLine(result);
}

private static async Task<string> SomeAsync() {
    await Task.Delay(2000);
    return "random String";
}

Here we start an async method from the Main method. The execution of this async method will take 2 seconds and by the time it completes the control will be back in the Main method at the line where we are blocking on the result of the async method. So we can say that the MainThread is blocked waiting for the result of SomeAsync. By the time SomeAsync completes, the MainThread is still blocked.

So can I say that the continuation of the async method will be executed on a different thread from the thread pool (as this code works and prints the string correctly)? Had it been a UI application it would have resulted in a deadlock but no deadlock in case of console application. Are the console applications contextless and may use a new thread from the thread pool when the need arises?

Answer 1

Use of async in your methods does not necessarily lead to the creation of a new thread:

Does the use of async/await create a new thread?

And particularly in your case, where you are actually running this method synchronously (no await), then this will very likely run on a single thread. To truly 'test' the async functionality, you should start awaiting results and then see what happens.

Answer 2

I try to show you how the async await works:

class Program
{
    static void Main(string[] args)
    {
        TestAsync().Wait(); //This will run synchronously
    }

    private static async Task TestAsync()
    {
        Log("Test started");

        Log("Application will be blocked for 5 seconds");
        await Wait5Seconds();
        Log("Now it will run again");

        var task = Wait20Seconds();
        while (!task.IsCompleted)
        {
            Log("This will be logged during method execution cause we didn't await it");
        }

        var task1 = Wait20Seconds();
        Log("We will execute this log and then we will await the end of the execution of our task");
        await task1;

        Log("Test ended");
    }

    private static async Task Wait5Seconds()
    {
        await Task.Delay(1000 * 5);
    }

    private static async Task Wait20Seconds()
    {
        await Task.Delay(1000 * 20);
        Log("DONE!");
    }

    private static void Log(string message)
    {
        Console.WriteLine(string.Format("{0} - {1}", DateTime.Now, message));
    }
}