C# gère les erreurs avec des exceptions capturées via try/catch/finally. Une bonne gestion des exceptions signifie capturer des types d'exceptions spécifiques, nettoyer les ressources (souvent avec using), créer des exceptions personnalisées significatives, et ne pas ignorer silencieusement les erreurs.
try
{
var data = RiskyOperation();
}
catch (FileNotFoundException ex) // catch SPECIFIC types (most specific first)
{
Console.WriteLine($"File missing: {ex.Message}");
}
catch (IOException ex)
{
Log(ex);
throw; // re-throw, PRESERVING the stack trace (not `throw ex`)
}
catch (Exception ex) // catch-all (last) — base of all exceptions
{
Log(ex);
}
finally
{
Cleanup(); // ALWAYS runs (success, exception, or return)
}
Capturez d'abord les types d'exceptions spécifiques, utilisez Exception comme filet de sécurité final, et finally pour le nettoyage qui doit toujours s'exécuter. Important : utilisez throw; (et non throw ex;) pour relancer — cela préserve la pile d'appels d'origine.
if (amount < 0)
throw new ArgumentException("Amount must be positive", nameof(amount));
// a custom exception for your domain
public class InsufficientFundsException : Exception
{
public InsufficientFundsException(string message) : base(message) { }
}
throw new InsufficientFundsException("Balance too low");
// `using` guarantees Dispose() is called (close files/connections) even on exception
using (var file = new StreamReader("data.txt"))
{
var content = file.ReadToEnd();
} // file.Dispose() called automatically here
using var conn = new SqlConnection(...); // C# 8 simplified form
L'instruction using garantit que les ressources IDisposable (fichiers, connexions) sont correctement disposées — la manière préférée de gérer le nettoyage des ressources, plus fiable qu'un finally manuel.
catch (Exception ex) when (ex.Message.Contains("timeout")) // exception filter (when)
{ ... }
✓ Catch SPECIFIC exceptions, not just Exception
✓ Use `using` for IDisposable resources (reliable cleanup)
✓ Don't swallow exceptions silently (empty catch) — log or re-throw
✓ Use `throw;` (not `throw ex;`) to preserve the stack trace
✓ Create meaningful custom exceptions; don't use exceptions for normal control flow
Une bonne gestion des exceptions est essentielle pour construire des applications C# robustes et fiables, donc bien la comprendre est important.
La structure try/catch/finally, capturer les types d'exceptions spécifiques (pour un traitement ciblé) avec Exception comme filet de sécurité final, et finally pour un nettoyage garanti, sont fondamentaux.
Plusieurs meilleures pratiques spécifiques à C# sont particulièrement importantes : utiliser throw; plutôt que throw ex; lors de la relance (un détail subtil mais crucial — throw ex; réinitialise la pile d'appels, perdant des informations de débogage précieuses), utiliser l'instruction using pour les ressources IDisposable (la manière préférée et fiable pour garantir que les fichiers, connexions et autres ressources sont correctement nettoyés même en cas d'exception — plus robuste que les blocs finally manuels, et central dans le modèle de gestion des ressources de C#), et ne pas ignorer les exceptions silencieusement.
Comprendre la gestion des exceptions — la structure, les captures spécifiques, les exceptions personnalisées, la relance qui préserve la pile d'appels, et en particulier using pour le nettoyage des ressources — est important pour écrire du C# fiable qui gère les erreurs élégamment et gère les ressources correctement.
Puisque les exceptions non traitées et les fuites de ressources causent de vrais problèmes de fiabilité, et puisque C# a des idiomes spécifiques (le motif using, la préservation avec throw;) qui distinguent le code robuste du code fragile, maîtriser la gestion des exceptions est une connaissance importante et fréquemment appliquée pour le développement professionnel en C#.