C# Async and Await

Reading a remote response or file often spends most of its time waiting for another system. Blocking a server thread or UI thread during that wait wastes capacity or freezes interaction. Asynchronous APIs represent the unfinished operation so the caller can yield control and resume when completion arrives.

CPU-bound work actively uses the processor. Marking a heavy calculation async does not make it faster. Parallel execution and background scheduling are separate decisions with costs and thread-safety concerns.

Task means an operation will finish later without a returned value; Task<T> will eventually produce T. Calling an async method starts it and returns its task. await checks that task: if incomplete, the method returns control to its caller; after completion, execution continues after the await.

The starter uses GetAwaiter().GetResult only as an adapter for the course's older console compiler entry point. In a current .NET console project, prefer static async Task Main() and await PrepareReportAsync() so asynchrony flows naturally rather than blocking at the top.

// Preferred in a current local .NET console project
static async Task Main()
{
  await PrepareReportAsync();
}

When a method calls an asynchronous API, it should usually become async and return a Task to its caller. Blocking with .Result or .Wait can waste threads and can deadlock in environments with a synchronization context. ‘Async all the way’ keeps cancellation and failure visible.

Avoid async void except for event-handler signatures. A caller cannot await its completion or catch its later exceptions normally. Returning Task makes completion part of the method contract.

static async Task<string> LoadMessageAsync(string path)
{
  string text = await File.ReadAllTextAsync(path);
  return text.Trim();
}

// Caller:
string message = await LoadMessageAsync("message.txt");

Starting two independent tasks before awaiting them can overlap their waiting time. Task.WhenAll waits for both. Do not parallelize operations that must occur in order or that mutate shared state without coordination.

Exceptions from awaited tasks are rethrown at the await and can be handled with normal try/catch. Cancellation is cooperative through CancellationToken: callers signal that results are no longer needed, and operations must observe the token. Timeouts, retries, and cancellation are related but distinct policies.

Task first = Task.Delay(300);
Task second = Task.Delay(500);

await Task.WhenAll(first, second);
Console.WriteLine("Both completed");