C# async/await Pitfalls Cheat Sheet

// 1. async void + lost exception
public async void Save() => await repo.SaveAsync();          // use Task

// 2. sync over async in ASP.NET Core
var user = userService.GetAsync(id).Result;                  // thread-pool starvation under load

// 3. early disposal (elided await)
public Task<string> ReadAsync()
{
    using var reader = File.OpenText(path);
    return reader.ReadToEndAsync();                          // reader disposed before the read completes
}

// 4. hidden async void
items.ForEach(async i => await SendAsync(i));                // List<T>.ForEach takes Action<T>

// 5. no cancellation, no bound
await Task.WhenAll(urls.Select(u => http.GetStringAsync(u))); // 10,000 concurrent requests

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>disable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

using System;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

// 1) await on Task.WhenAll rethrows only one exception; the task keeps all of them.
var all = Task.WhenAll(FailAsync("A"), FailAsync("B"));
try { await all; }
catch (Exception ex)
{
    Console.WriteLine($"await caught one exception: {ex is InvalidOperationException}");
    Console.WriteLine($"all.Exception holds: {string.Join(", ", all.Exception!.InnerExceptions.Select(e => e.Message).Order())}");
}

// 2) Eliding async/await inside a using block disposes the resource too early.
try { await ReadElidedAsync(); }
catch (ObjectDisposedException) { Console.WriteLine("Elided version: ObjectDisposedException"); }
Console.WriteLine($"Awaited version read: {await ReadAwaitedAsync()}");

// 3) Exceptions are stored on the Task until it is awaited (a fire-and-forget Task hides them).
var unobserved = FailAsync("C");
await Task.WhenAny(unobserved); // wait for completion without observing its exception
Console.WriteLine($"Fire-and-forget task faulted silently: {unobserved.IsFaulted}");
try { await unobserved; } catch (InvalidOperationException ex) { Console.WriteLine($"Observed only on await: {ex.Message}"); }

// 4) Cancellation surfaces as OperationCanceledException (TaskCanceledException derives from it).
using var cts = new CancellationTokenSource();
cts.Cancel(); // make cancellation deterministic instead of racing two timers
try { await Task.Delay(TimeSpan.FromSeconds(5), cts.Token); }
catch (OperationCanceledException ex) { Console.WriteLine($"Cancelled: {ex.GetType().Name}"); }

static async Task FailAsync(string name)
{
    await Task.Yield();
    throw new InvalidOperationException(name);
}

static Task<string> ReadElidedAsync()
{
    var gate = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
    Task<string> pending;
    using (var reader = new StringReader("hello"))
    {
        pending = SlowReadAsync(reader, gate.Task); // no await: the scope ends while work is pending
    }
    gate.SetResult(); // the reader is now definitely disposed before the read can proceed
    return pending;
}

static async Task<string> ReadAwaitedAsync()
{
    using var reader = new StringReader("hello");
    return await SlowReadAsync(reader); // reader stays alive until the read completes
}

static async Task<string> SlowReadAsync(TextReader reader, Task? gate = null)
{
    await (gate ?? Task.Delay(10));
    return reader.ReadToEnd();
}

await caught one exception: True
all.Exception holds: A, B
Elided version: ObjectDisposedException
Awaited version read: hello
Fire-and-forget task faulted silently: True
Observed only on await: C
Cancelled: TaskCanceledException