Async & await

Blocking holds a thread hostage until the call finishes. await instead registers a continuation and hands the thread back to the pool, so it serves other work while the operation is in flight. It buys throughput and responsiveness, never raw speed.

async void returns no Task, so the caller cannot await it, cannot see when it ends, and cannot catch its exception — the failure is rethrown on the captured context and tears the process down. Use async Task everywhere except event handlers, whose signature forces void.

A CancellationToken is a read-only signal the caller passes down so callees can see a cancellation request. Only its owner, a CancellationTokenSource, can trip it, by calling Cancel(). The token stops nothing itself — it merely reports IsCancellationRequested.

A Task is a handle to an operation that is already under way — a promise of a future result, not a thread and not the work itself. It ends up RanToCompletion, Faulted with an exception, or Canceled; Task<T> also carries the produced value.

Task.WhenAll returns a task that completes once every input task has finished, yielding all the results together. Task.WhenAny completes as soon as the first one finishes and hands you that task; the rest keep running. Both are awaited, not blocked on.

I/O has no thread behind it — the device works while the OS holds a completion callback, so await can release the thread outright. CPU work needs instructions executing the whole time, so some thread must sit on it; Task.Run frees the caller but still burns a pool thread.

await FooAsync() starts the method on the current thread and runs it inline up to its first real await. Task.Run first hands the delegate to a thread-pool thread, so that synchronous prefix runs there instead. For I/O-bound work the extra hop buys nothing and just burns a thread.

Blocking APIs — .Wait(), .Result, Task.WaitAll — wrap failures in an AggregateException, since several tasks may have failed at once. await unwraps it and rethrows only the first inner exception, so a failed Task.WhenAll throws one; the rest stay in the task's Exception.InnerExceptions.

Cancellation is cooperative — nothing aborts the method for you. It must flow the token into every awaitable call it makes and call ThrowIfCancellationRequested() between chunks of work. That throws OperationCanceledException, putting the task in Canceled, not Faulted.

Task<List<T>> is awaited once and materialises the whole batch in memory. IAsyncEnumerable<T> yields items one at a time and may await between them, so await foreach processes the first item while later ones are still being fetched — streaming, without buffering everything.

Task<T> is a class, so every call allocates one even when the result is already cached. ValueTask<T> is a struct wrapping either the value or a Task<T>, so a synchronously-completed hot path allocates nothing. The catch: await it exactly once, never twice.

The call is missing its await, so the returned Task is discarded. An async method does not throw into the caller's frame — it captures the failure onto its Task and rethrows only when that task is awaited. Fix it by writing await _repository.SaveAsync(order);.

A failing async Task method catches the exception inside its state machine and stores it on the task via SetException; the awaiter later rethrows it through ExceptionDispatchInfo, which preserves the original stack trace instead of resetting it. async void has no task to store it on, so its builder rethrows the exception on the captured SynchronizationContext — or on the thread pool — where nobody is awaiting, and the process dies.

The compiler rewrites the method into a state machine whose MoveNext() resumes at each await; the locals become its fields. At an await it asks the awaiter whether the operation already completed — if so it continues inline; if not, the builder boxes the machine onto the heap, hooks MoveNext on as the continuation, and the thread leaves. Completion re-enters MoveNext at the saved state.

A consumer cancels a stream through await foreach (... .WithCancellation(ct)), which passes the token to GetAsyncEnumerator(ct) — not to the iterator's own parameters, which were bound back when the method was first called. [EnumeratorCancellation] tells the compiler to route that enumerator-level token into the marked parameter, linking it with whatever token was passed at call time.