async / await sans douleur

// 1. La méthode qui attend est marquée async et renvoie Task (ou Task<T>)
// 2. Son nom finit par Async (convention universelle)
// 3. On écrit await devant l'appel qui prend du temps
public async Task<Client> ChargerClientAsync(int id)
{
    var client = await _db.Clients.FindAsync(id);       // attente sans blocage
    var commandes = await _api.GetCommandesAsync(id);   // puis une autre
    client.Commandes = commandes;
    return client;                 // ← on renvoie un Client, pas un Task<Client>
}

public async void Traiter()          // ❌ personne ne peut attendre cette méthode
{
    await Task.Delay(100);
    throw new Exception("perdu");    // 💥 exception non observable → crash du processus
}

public async Task TraiterAsync()     // ✅ l'appelant peut await, et attraper l'exception
{
    await Task.Delay(100);
}

// En Minimal API, ASP.NET Core fournit le jeton automatiquement :
// il est annulé si le client ferme l'onglet ou si le délai est dépassé.
app.MapGet("/recherche", async (string q, AppDbContext db, CancellationToken ct) =>
{
    var resultats = await db.Produits
        .Where(p => p.Nom.Contains(q))
        .Take(50)
        .ToListAsync(ct);          // ← on le transmet !
    return Results.Ok(resultats);
});

// Le propager partout, jusqu'au bout de la chaîne
public async Task<Rapport> GenererAsync(CancellationToken ct)
{
    var données = await _db.ChargerAsync(ct);
    ct.ThrowIfCancellationRequested();          // point de contrôle dans un long calcul
    return Composer(données);
}

// Poser un délai maximal
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
var r = await http.GetStringAsync(url, cts.Token);

// Le producteur : les éléments arrivent progressivement
async IAsyncEnumerable<Ligne> LireLignesAsync(
    [EnumeratorCancellation] CancellationToken ct = default)
{
    await using var flux = File.OpenRead("gros.csv");
    using var lecteur = new StreamReader(flux);
    while (await lecteur.ReadLineAsync(ct) is { } ligne)
        yield return Analyser(ligne);
}

// Le consommateur
await foreach (var ligne in LireLignesAsync(ct))
    Traiter(ligne);          // le premier élément est traité sans attendre le dernier

try
{
    await ChargerAsync();                 // l'exception se propage normalement
}
catch (HttpRequestException ex) { /* ... */ }
catch (OperationCanceledException) { /* annulation : souvent normal, pas une erreur */ }

// Avec WhenAll, SEULE la première exception est levée par await…
var taches = urls.Select(u => TelechargerAsync(u)).ToList();
try { await Task.WhenAll(taches); }
catch (Exception)
{
    // …mais toutes sont accessibles ainsi :
    foreach (var t in taches.Where(t => t.IsFaulted))
        Console.WriteLine(t.Exception!.InnerException!.Message);
}