Async & Await in C#

1. Why Async? Threads Are Expensive

Kunal orders pizza. Sync way: stand at door 30 mins, doing nothing. Thread blocked. Async way: order, set timer, watch TV. When bell rings, pause TV, get pizza, resume. Thread was free to do other work.

// Sync: blocks thread for 30 mins
void OrderSync() {
    Pizza p = PizzaService.Order(); // Thread waits here
    Eat(p);
}

// Async: thread released during wait
async Task OrderAsync() {
    Pizza p = await PizzaService.OrderAsync(); // Thread goes do other stuff
    Eat(p); // Resumes when pizza ready
}

2. await = "Come Back Later"

await doesn't start work. It waits for work that's already running. If Prerna calls await DownloadAsync(), the download starts, then her method returns a Task to caller.

3. Task vs void: Never async void

async Task = awaitable. async void = fire-and-forget. You can't catch exceptions from async void. Only use for event handlers.

public async Task SaveAsync() { } // Good
public async void Button_Click() { } // Only for events

1. Why Do We Need Async/Await?

I/O is slow. Network, disk, DB take milliseconds. CPU runs billions of ops in that time. Blocking a thread on I/O wastes it. With async, same 1000 calls use maybe 10 threads. Threads do work, hit await, go handle other requests, come back when I/O done. Massive scale.

2. The State Machine: What async Compiles To

async methods become state machines. Compiler splits code at each await. Local vars become fields.

async Task GetNameAsync() {
    var id = GetId(); // State 0
    var name = await Api(id); // State 1, returns here
    return name.ToUpper(); // State 2
}

3. ConfigureAwait(false): Library Code Rule

By default, await captures SynchronizationContext and resumes on UI thread. Library code doesn't care about UI thread.

public async Task GetDataLibAsync() {
    var json = await http.GetStringAsync(url).ConfigureAwait(false); // Don't capture context
    return Parse(json);
}

Rule: If you're writing library code, use ConfigureAwait(false). If you're writing UI code and need to update UI after await, don't use it.

4. Parallel vs Concurrent: Task.WhenAll

Want to call 3 APIs? Don't await one by one. That's sequential. Start all, then await all.

// Slow: 1s + 1s + 1s = 3s
var a = await Api1();
var b = await Api2();
var c = await Api3();

// Fast: max(1s,1s,1s) = 1s
var t1 = Api1();
var t2 = Api2();
var t3 = Api3();
await Task.WhenAll(t1, t2, t3);

5. Memory: Tasks Are Objects, Threads Are Not

Every async method allocates a state machine + Task if not completed synchronously. That's ~100 bytes. Cheap. Creating a thread = 1MB stack. That's why async scales. Sanju spinning 10k threads = 10GB RAM. 10k Tasks = 1MB. Thread pool threads get reused when awaited. No new OS threads created for I/O.