Asynchronous Programming

async Task ProcessAsync(CancellationToken token) {
  for (int i = 0; i < 1000000; i++) {
    token.ThrowIfCancellationRequested(); // cooperative cancellation check
    await DoWorkAsync(i, token); // token passed further down the chain
  }
}

var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(5));
await ProcessAsync(cts.Token);

Common follow-ups: What exception type is thrown when ThrowIfCancellationRequested() detects cancellation, and how should it typically be handled?

// Conceptual illustration of what the compiler generates behind the scenes:
// class MethodNameStateMachine : IAsyncStateMachine {
//   int state;
//   TaskAwaiter awaiter;
//   void MoveNext() { /* resumes execution from the last await point */ }
// }

Common follow-ups: Under what conditions does the compiler generate a STRUCT-based state machine instead of a class-based one, and why does that matter for allocations?

public ValueTask<int> GetCachedValueAsync(string key) {
  if (cache.TryGetValue(key, out int value)) {
    return new ValueTask<int>(value); // synchronous path: zero Task allocation
  }
  return new ValueTask<int>(FetchAndCacheAsync(key)); // genuinely async path
}

Common follow-ups: Why is it specifically unsafe to await the same ValueTask<T> instance more than once?

async IAsyncEnumerable<string> FetchPagesAsync(string url) {
  string? next = url;
  while (next != null) {
    var (items, nextUrl) = await FetchPageAsync(next);
    foreach (var item in items) yield return item;
    next = nextUrl;
  }
}

await foreach (var item in FetchPagesAsync(startUrl)) {
  Console.WriteLine(item);
}

Common follow-ups: Can an IAsyncEnumerable<T> sequence also accept a CancellationToken to support cancellation mid-stream?

var channel = Channel.CreateBounded<int>(capacity: 100);

// Producer
_ = Task.Run(async () => {
  for (int i = 0; i < 1000; i++) await channel.Writer.WriteAsync(i);
  channel.Writer.Complete();
});

// Consumer
await foreach (var item in channel.Reader.ReadAllAsync()) {
  Console.WriteLine(item);
}

Common follow-ups: How does a BOUNDED channel's WriteAsync() behave differently from an unbounded one when the channel is full?

public async Task<string> GetDataAsync() {
    await Task.Delay(2000); // simulates a slow I/O operation, without blocking the thread
    return "Data received";
}

public async Task ShowData() {
    string data = await GetDataAsync(); // pauses here until GetDataAsync completes
    Console.WriteLine(data);
}

Common follow-ups: What happens if you forget the await keyword in front of an async method call?;Why does calling .Result or .Wait() on a Task risk a deadlock in certain contexts?

async IAsyncEnumerable<int> GenerateNumbersAsync() {
    for (int i = 1; i <= 5; i++) {
        await Task.Delay(1000); // simulating a slow data source
        yield return i;
    }
}

await foreach (var number in GenerateNumbersAsync()) {
    Console.WriteLine(number); // processes each value as it arrives, without blocking
}

Common follow-ups: How does await foreach differ from a plain foreach in terms of what happens between iterations?;What's the memory advantage of IAsyncEnumerable<T> over loading an entire large dataset into a List<T> first?

// Thread: a dedicated, manually managed execution path
Thread thread = new(() => Console.WriteLine("Running in a thread"));
thread.Start();

// Task: uses the thread pool automatically, integrates with async/await
await Task.Run(() => Console.WriteLine("Running in a task"));

Common follow-ups: Why does the thread pool make Task more scalable than manually created Threads for short-lived work?;In what specific scenario would a dedicated, long-running Thread genuinely be the better choice today?

// Task<T>: always allocates, even for an already-known result
public async Task<int> GetValueAsync() => await Task.FromResult(42);

// ValueTask<T>: avoids the allocation entirely when the result is already available
public ValueTask<int> GetValueAsync() => new ValueTask<int>(42);

// If genuine async work is sometimes needed, it can still wrap a real Task<T>
public ValueTask<int> GetCachedOrFetchAsync(string key) =>
    _cache.TryGetValue(key, out int value) ? new ValueTask<int>(value) : new ValueTask<int>(FetchAsync(key));

Common follow-ups: What specific bug can occur if a ValueTask<T> is awaited more than once?;In what scenario would using ValueTask<T> actually hurt readability or correctness enough to not be worth the optimization?

public async Task<int> FetchDataAsync() {
    await Task.Delay(1000);
    return 42;
}
// Conceptually compiles to something resembling:
public Task<int> FetchDataAsync() {
    var stateMachine = new FetchDataStateMachine();
    stateMachine.MoveNext(); // runs synchronously until the first await, then returns control
    return stateMachine.Task;
}

Common follow-ups: Why specifically does calling .Result from a UI thread risk a deadlock that calling it from a console app's Main method usually doesn't?;What does ConfigureAwait(false) actually change about which thread a continuation resumes on?