Erreurs, null et robustesse

try
{
    var contenu = File.ReadAllText(chemin);
    return JsonSerializer.Deserialize<Config>(contenu);
}
catch (FileNotFoundException ex)          // du plus précis…
{
    _log.LogWarning(ex, "Fichier {Chemin} absent, configuration par défaut", chemin);
    return Config.Defaut;
}
catch (JsonException ex)
{
    throw new ConfigInvalideException($"Le fichier {chemin} est illisible", ex);  // ← on enveloppe
}
finally
{
    _compteur.Increment();                // exécuté quoi qu'il arrive
}

public class StockInsuffisantException(string reference, int demande, int disponible)
    : Exception($"Stock insuffisant pour {reference} : {demande} demandés, {disponible} disponibles")
{
    public string Reference { get; } = reference;      // ← données exploitables par l'appelant
    public int Demande { get; } = demande;
    public int Disponible { get; } = disponible;
}

// Utilisation : l'appelant peut réagir intelligemment
catch (StockInsuffisantException ex) when (ex.Disponible > 0)
{
    return ProposerCommandePartielle(ex.Reference, ex.Disponible);
}

public async Task<Facture> CreerAsync(Commande commande, string devise, CancellationToken ct)
{
    ArgumentNullException.ThrowIfNull(commande);                        // .NET 6+
    ArgumentException.ThrowIfNullOrWhiteSpace(devise);                  // .NET 8+
    ArgumentOutOfRangeException.ThrowIfNegativeOrZero(commande.Total);  // .NET 8+

    if (commande.Statut != Statut.Validee)
        throw new InvalidOperationException($"Commande {commande.Id} non validée");

    // ← à partir d'ici, tout est garanti valide : le corps reste plat et lisible
    return await ConstruireAsync(commande, devise, ct);
}

// Déclaration using : libéré à la fin du bloc englobant. La forme moderne, à préférer.
using var flux = File.OpenRead("data.bin");
using var lecteur = new StreamReader(flux);
var texte = await lecteur.ReadToEndAsync();
// Dispose() appelé automatiquement ici, même en cas d'exception

// Version asynchrone
await using var connexion = new SqlConnection(chaine);
await connexion.OpenAsync(ct);

// Implémenter le contrat soi-même
public sealed class FichierTemporaire : IDisposable
{
    public string Chemin { get; } = Path.GetTempFileName();
    public void Dispose() => File.Delete(Chemin);
}

public class Client
{
    public required string Nom { get; init; }     // jamais null, obligatoire à la création
    public string? Surnom { get; init; }          // peut être null, et c'est assumé
    public List<Commande> Commandes { get; } = [];// jamais null : initialisé
}

void Afficher(Client c)
{
    Console.WriteLine(c.Nom.ToUpper());           // ✅ aucun avertissement
    Console.WriteLine(c.Surnom.ToUpper());        // ⚠️ CS8602 : peut être null

    // Les quatre bonnes façons de traiter le cas :
    Console.WriteLine(c.Surnom?.ToUpper());               // null si null
    Console.WriteLine(c.Surnom?.ToUpper() ?? "(aucun)");  // valeur de repli
    if (c.Surnom is not null) Console.WriteLine(c.Surnom.ToUpper());
    if (!string.IsNullOrWhiteSpace(c.Surnom)) Console.WriteLine(c.Surnom.ToUpper());
}

builder.Services.AddValidation();      // active la validation automatique des endpoints

public record CreerClient(
    [Required, StringLength(80, MinimumLength = 2)] string Nom,
    [Required, EmailAddress]                        string Email,
    [Range(18, 130)]                                int Age);

app.MapPost("/clients", (CreerClient dto) => TypedResults.Created($"/clients/1", dto));
// Si le corps est invalide : 400 + ProblemDetails détaillant chaque champ,
// AVANT même l'entrée dans ton code.

// Le type lui-même garantit sa validité : plus besoin de revérifier ailleurs
public readonly record struct Email
{
    public string Valeur { get; }

    private Email(string v) => Valeur = v;

    public static Email Creer(string saisie)
    {
        if (string.IsNullOrWhiteSpace(saisie) || !saisie.Contains('@'))
            throw new ArgumentException($"Email invalide : {saisie}");
        return new Email(saisie.Trim().ToLowerInvariant());
    }

    public static bool TryCreer(string saisie, out Email resultat) { /* ... */ }
    public override string ToString() => Valeur;
}

// Signature qui se documente elle-même — impossible de passer un email non validé
public Task EnvoyerAsync(Email destinataire, string sujet) { /* ... */ }

public abstract record Resultat<T>
{
    public record Succes(T Valeur) : Resultat<T>;
    public record Echec(string Code, string Message) : Resultat<T>;
}

public async Task<Resultat<Client>> InscrireAsync(CreerClient dto)
{
    if (await _db.Clients.AnyAsync(c => c.Email == dto.Email))
        return new Resultat<Client>.Echec("EMAIL_PRIS", "Cet email est déjà utilisé");

    var client = new Client { Nom = dto.Nom, Email = dto.Email };
    _db.Add(client);
    await _db.SaveChangesAsync();
    return new Resultat<Client>.Succes(client);
}

// À l'appel : tous les cas sont traités, le compilateur le vérifie
return await InscrireAsync(dto) switch
{
    Resultat<Client>.Succes s => Results.Created($"/clients/{s.Valeur.Id}", s.Valeur),
    Resultat<Client>.Echec e   => Results.Conflict(new { e.Code, e.Message }),
    _ => Results.Problem()
};

// Program.cs — un seul endroit pour transformer une exception en réponse HTTP propre
builder.Services.AddProblemDetails();
builder.Services.AddExceptionHandler<GestionnaireErreurs>();

var app = builder.Build();
app.UseExceptionHandler();     // à placer très tôt dans le pipeline

// ------------------------------------------------------------
public sealed class GestionnaireErreurs(ILogger<GestionnaireErreurs> log) : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(HttpContext ctx, Exception ex, CancellationToken ct)
    {
        var (statut, titre) = ex switch
        {
            StockInsuffisantException => (StatusCodes.Status409Conflict, "Stock insuffisant"),
            KeyNotFoundException      => (StatusCodes.Status404NotFound, "Introuvable"),
            ArgumentException         => (StatusCodes.Status400BadRequest, "Requête invalide"),
            _                         => (StatusCodes.Status500InternalServerError, "Erreur interne")
        };

        // On journalise TOUT côté serveur, avec l'identifiant de trace…
        log.LogError(ex, "Échec {Trace} sur {Chemin}", ctx.TraceIdentifier, ctx.Request.Path);

        // …mais on ne divulgue jamais la pile d'appels au client
        await Results.Problem(
            title: titre,
            statusCode: statut,
            extensions: new Dictionary<string, object?> { ["traceId"] = ctx.TraceIdentifier })
            .ExecuteAsync(ctx);
        return true;
    }
}