What makes these async method calls different?

Question

I was reading a chapter about the await and async keywords in my C# book. It was mainly explaining these kinds of method calls, where the caller uses the await keyword to wait for the called method to finish.

In this simple example I see no advantage but more importantly no difference in these 3 calls. Can anyone explain what difference it makes to the flow of the application? Is it only useful when the calling thread is the main GUI thread?

static async Task Main(string[] args)
{
    WriteText();

    await WriteTextAsync();

    WriteTextAsync().Wait();
}

static void WriteText()
{
    Thread.Sleep(3_000);
    Console.WriteLine("Hello");
}

static async Task WriteTextAsync()
{
    await Task.Run(() =>
    {
        Thread.Sleep(3_000);
        Console.WriteLine("Hello");
    });
}

Ps: If the calling thread of the method is waiting for the method to finish anyway it might as well be a normal call?

Answer 1

As my understanding about your question is

If the program waits for the response in await WriteTextAsync() line then what will be the benifit?

For client applications, such as Windows Store, Windows desktop and Windows Phone apps, the primary benefit of async is responsiveness. These types of apps use async chiefly to keep the UI responsive. For server applications, the primary benefit of async is scalability.

I will try to explain from the web-app point of view.

Suppose you have a web application depends on external resources like database call, when a client initiates a request ASP.NET takes one of its thread pool threads and assigns it to that request. Because it’s written synchronously, the request handler will call that external resource synchronously. This blocks the request thread until the call to the external resource returns. Figure 1 illustrates a thread pool with two threads, one of which is blocked waiting for an external resource.

Figure 1 Waiting Synchronously for an External Resource

Now if third client requests at the same time then there is no thread in thread pool available to assign the third request.

In asynchronous call, thread will not be stuck rather will be released and comes back to the thread pool which will facilitates to serve the third call.

When request server activities ends linke database call ends then SynchronizationContext resumes that call and returns repose to client.

Bellow image in simple analogy of aync call

There is lot of things happens under the hood. I wrote this maily from Async Programming : Introduction to Async/Await on ASP.NET and my understanding. It is highly recommended to have clear understanding before using async-wait.

Answer 2

When you say WriteText(), WriteText() will block your current thread until it completes, as it is synchronous.

When you say await WriteTextAsync(), you will spawn a new thread and you will not block computations that do not depend on the result of WriteTextAsync().
EDIT: According to Microsoft Docs When you say await WriteTextAsync(), the compiler schedules the rest of Main() for execution after WriteTextAsync() completes. Then the control is supposed to be returned to the caller of the async method. But who is the caller of Main()? As it turns out, there is no async Main() - it is actually the same synchronous Main() - and it's just syntactical sugar for not writing .Wait() inside it. So in this case this call is equivalent to WriteTextAsync().Wait()!

Finally, when you say WriteTextAsync().Wait(), you block your current thread again and wait for the result of WriteTextAsync().

Answer 3

I'll be referring to:

//Call 1
WriteText();

//Call 2    
await WriteTextAsync();

//Call 3
WriteTextAsync().Wait();

The first call doesn't have any problem, if what you want to do is a synchronous wait. In a Console application, this is quite normal.

The problem arises in programs with a UI or those that require the best use of CPU resources, the most common case being web applications.

Call 2, using await performs an asynchronous wait for the result of WriteTextAsync. In its own, that's fine and what's considered normal. However, WriteTextAsync is a very good example of something you should never do:

static async Task WriteTextAsync()
{
    // Let's create a Thread
    await Task.Run(() =>
    {
        // just to block it completely, having it do nothing useful
        Thread.Sleep(3_000);
        Console.WriteLine("Hello");
    });
}

Rather, the author should have used:

static async Task WriteTextAsync()
{
    // Let's *not* create a new thread
    await Task.Delay(3_000);
    Console.WriteLine("Hello");
}

Maybe they were to point this out further down the line, but you didn't give us the book name to know this.

Call number 3 is what you would have to do when the calling method cannot be an async one and you have to call an async method, so:

// Think that for some reason you cannot change the signature, 
// like in the case of an interface, and an async void would make your code
// never complete correctly
static void Main(string[] args)
{
    //Call 3
    WriteTextAsync().Wait();
}

Overall, I would suggest you to find a better book. Examples are easier to understand when asynchronous code is actually required.