async and await: waiting without blocking

The problem: waiting wastes threads

A thread is a worker that runs your code. Calling a payment gateway might take 800 milliseconds, and almost all of it is just waiting for the reply. If the thread sits blocked during that wait, it cannot do anything else. In a desktop app the window freezes. In a web server, each blocked thread is one fewer request it can serve, so under load the site slows down or fails.

Task and Task<T>

A Task is a promise of work that will complete in the future. Task<T> also promises a result of type T. You do not usually create them by hand; .NET methods that do I/O return them, and their names end in Async: File.ReadAllTextAsync, HttpClient.GetStringAsync, SaveChangesAsync.

Writing an async method

static async Task<string> GetGreetingAsync(string name)
{
    await Task.Delay(1000);          // pretend this is a slow network call
    return $"Namaste, {name}";
}

string message = await GetGreetingAsync("Asha");   // top-level await works in Program.cs
Console.WriteLine(message);

What await really does

1. The method runs normally until it reaches an await on something that is not finished yet.
2. It pauses there and returns an unfinished Task to its caller. The thread is free to do other work.
3. When the awaited operation finishes, the rest of the method continues (possibly on another thread).
4. When the method returns, its Task completes, and whoever awaited it continues.

Console.WriteLine("1");
Task work = SlowAsync();
Console.WriteLine("2");
await work;
Console.WriteLine("4");

static async Task SlowAsync()
{
    await Task.Delay(500);
    Console.WriteLine("3");
}

Doing several things at once: Task.WhenAll

using System.Diagnostics;

var watch = Stopwatch.StartNew();
Task<decimal> fare = GetFareAsync();        // starts now
Task<int> seats = GetSeatsAsync();          // also starts now
await Task.WhenAll(fare, seats);            // wait for both
Console.WriteLine($"Fare {fare.Result}, seats {seats.Result}, took about {watch.ElapsedMilliseconds} ms");

static async Task<decimal> GetFareAsync() { await Task.Delay(2000); return 1450m; }
static async Task<int> GetSeatsAsync() { await Task.Delay(1500); return 23; }

A real example: calling a web API

using var http = new HttpClient();
http.Timeout = TimeSpan.FromSeconds(10);
string body = await http.GetStringAsync("https://api.github.com/zen",
    CancellationToken.None);

The rules that prevent most async bugs

I/O-bound versus CPU-bound

async helps with I/O-bound work: waiting for network, disk or database. It does not make calculations faster. For heavy CPU work, like resizing 500 photos, the work itself needs a thread; in a desktop app you can move it off the UI thread with await Task.Run(() => Resize(photos)). In ASP.NET Core, avoid wrapping CPU work in Task.Run just to look async.

Exceptions and cancellation

If an awaited task fails, await rethrows its exception, so a normal try/catch around await works. Long operations usually accept a CancellationToken so they can be stopped, for example when a user leaves the page.