"await" Expression and Child Thread

C# Tutorials - Herong's Tutorial Examples

∟"await" Expression and Child Thread

A tutorial example is provided on how to use the 'await' expression on an awaitable task to launch a child thread to wait for the task to complete.

After learning the asynchronous behavior of the GetStringAsync() method from the HttpClient class, we can take a closer look at the "await" operator now.

According to the C# 5 specification, the "await" operator works under the following rules:

"await" is a unary operator, taking only one operand.
"await" operand must an awaitable task, or an awaitable instance of System.Threading.Tasks.Task class.
An "await" expression is only allowed in the body of an async function.
"await t" is equivalent to "t.GetAwaiter().GetResult()".

The evaluation of "await t" goes roughly like this:

Create a new child thread to wait for the completion of the task "t".
Immediately suspend the execution of the remaining portion of the current method.
Return execution control to the caller on the current thread.
When the task "t" is completed, it's "Result" is returned as the value of the "await t" expression.
Execution of the remaining portion of the current method is resumed on the child thread.

Based on Microsoft examples, the task returned by "GetStringAsync()" seems to be awaitable task. So let's use it in an "await" expression in a tutorial example, AwaitExpressionTest.cs:

// AwaitExpressionTest.cs
// Copyright (c) 2016 HerongYang.com. All Rights Reserved.

using System;
using System.Net.Http;
using System.Threading.Tasks;
public class AwaitExpressionTest {
   static void Main() {
      Console.WriteLine("Before 'await' ...");	
      AwaitTest();
      Console.WriteLine("After 'await' ...");	
   }
   async static void AwaitTest() {
      string uri = "https://www.herongyang.com/Service/Hello_REST.php";
      HttpClient c = new HttpClient();
      Console.WriteLine("Calling GetStringAsync()...");	
      Task<string> t = c.GetStringAsync(uri);
      Console.WriteLine("Evaluating await-expression ...");	
      string s = await t;
      Console.WriteLine("Writing task result ...");	
      Console.WriteLine(s);
   }
}

If you compile and run this tutorial example with .NET Framework 4.6.1 SDK, you will get:

C:\herong>%NET%\csc "/r:%REF%/System.Net.Http.dll"
   AwaitExpressionTest.cs
Microsoft (R) Visual C# Compiler version 4.6.1055.0
for C# 5
Copyright (C) Microsoft Corporation. All rights reserved.

C:\herong>AwaitExpressionTest
Before 'await' ...
Calling GetStringAsync()...
Evaluating await-expression ...
After 'await' ...

Not too bad. The tutorial example worked. But the remaining portion of the AwaitTest() method after the "await" expression did not get a chance to be executed. Here is my understanding of what happened:

When the main thread reached "GetStringAsync()", it launched a child thread #1 to go to finish the HTTP GET request.
The main thread then continued immediately.
When the main thread reached "await t", it launched a child thread #2 to go to wait for "t" to finish.
The main thread exited the AwaitTest() immediately.
The main thread then continued in the Main() method and ended the program quickly.

Child thread #2 was supposed to continue with statements after "await t" after Child thread #1 reached to the end. But main thread ended before that occurred as shown in the diagram below: