📝 Lesson 4.3: Asynchronous Programming

Why Async?

Most slow operations aren't slow because your CPU is busy — they're slow because your program is waiting: for a disk, a network response, a database. In synchronous code, that waiting blocks the thread; nothing else can happen until it finishes. A UI would freeze; a server could handle far fewer requests.

The analogy: at a restaurant, a good waiter takes your order, then serves other tables while the kitchen cooks — rather than standing frozen at your table until your food is ready. Async lets one thread serve many "tables."

Tasks

A Task represents an operation that's in progress or will complete in the future — a promise of "this work is happening; here's a handle to it."

• Task — an async operation that returns no value (the async equivalent of void).
• Task<T> — an async operation that will produce a value of type T (the generic type from Lesson 1.2).

Many .NET methods that do slow I/O come in async versions that return a Task, conventionally suffixed with Async. For example, the file methods from Lesson 4.1 have async twins:

// Synchronous (blocks): string text = File.ReadAllText("big.txt");
// Asynchronous (returns a Task<string>):
Task<string> readTask = File.ReadAllTextAsync("big.txt");

That readTask is the operation in flight. To get its result, you await it — our next topic.

async and await

Two keywords make async code read almost like ordinary sequential code:

• async marks a method as asynchronous, allowing await inside it.
• await pauses the method until the awaited Task completes, then continues — without blocking the thread while waiting.

async Task GreetSlowlyAsync()
{
    Console.WriteLine("Starting...");
    await Task.Delay(1000);            // wait 1 second WITHOUT blocking
    Console.WriteLine("...done a second later!");
}

Task.Delay is a handy stand-in for "some slow work." Because we await it, the thread is free during that second. Crucially, await unwraps the task: awaiting a Task<string> gives you a string:

async Task ShowFileAsync()
{
    string text = await File.ReadAllTextAsync("notes.txt");   // await → string
    Console.WriteLine(text);
}

Returning Values

An async method that produces a result declares its return type as Task<T>, but inside you just return the T — the compiler wraps it in a task for you:

async Task<int> CalculateSlowlyAsync(int a, int b)
{
    await Task.Delay(500);      // pretend this takes time
    return a + b;               // return an int; caller gets Task<int>
}

// Calling it:
int sum = await CalculateSlowlyAsync(3, 4);
Console.WriteLine(sum);         // 7

From the caller's perspective, await CalculateSlowlyAsync(3, 4) reads just like a normal method call that returns an int — the async machinery stays out of your way.

Running Work Concurrently

Awaiting tasks one after another runs them sequentially. If they don't depend on each other, you can start them all and wait for all to finish with Task.WhenAll — often dramatically faster:

async Task<string> FetchAsync(string name)
{
    await Task.Delay(1000);      // each "fetch" takes ~1 second
    return $"Data for {name}";
}

// ❌ Sequential: ~3 seconds total (1 + 1 + 1)
string a = await FetchAsync("A");
string b = await FetchAsync("B");
string c = await FetchAsync("C");

// ✅ Concurrent: ~1 second total — all three run at once
Task<string>[] tasks =
{
    FetchAsync("A"),
    FetchAsync("B"),
    FetchAsync("C")
};
string[] results = await Task.WhenAll(tasks);
foreach (string r in results)
{
    Console.WriteLine(r);
}

Common Pitfalls

// ❌ Blocks (and can deadlock)
string text = File.ReadAllTextAsync("f.txt").Result;

// ✅ Awaits properly
string text = await File.ReadAllTextAsync("f.txt");

try
{
    string text = await File.ReadAllTextAsync("missing.txt");
}
catch (FileNotFoundException)
{
    Console.WriteLine("File not found.");
}

Exercise & Quiz

// Top-level code can use await directly.

// TODO: call DownloadAsync three times concurrently with Task.WhenAll
// TODO: print each result

async Task<string> DownloadAsync(string name)
{
    await Task.Delay(1000);
    return $"Downloaded {name}";
}

// Concurrent version
Task<string> t1 = DownloadAsync("report.pdf");
Task<string> t2 = DownloadAsync("photo.jpg");
Task<string> t3 = DownloadAsync("data.csv");

string[] results = await Task.WhenAll(t1, t2, t3);   // ~1 second total

foreach (string r in results)
{
    Console.WriteLine(r);
}

async Task<string> DownloadAsync(string name)
{
    await Task.Delay(1000);   // simulate a slow download
    return $"Downloaded {name}";
}

Downloaded report.pdf
Downloaded photo.jpg
Downloaded data.csv

Summary

📚 Additional Resources

• Asynchronous programming — Microsoft Docs
• Async in depth & scenarios
• Task — API reference

🚀 What's Next?

That completes Module 4! Async is the key to our next topic. In Module 5, you'll put it to real use: Lesson 5.1: Calling Web APIs with HttpClient fetches live data over the internet — asynchronously, of course — and parses the JSON you learned in Lesson 4.2.