C# verwerkt fouten met exceptions die via try/catch/finally worden afgevangen. Goed exception handling betekent specifieke exception-typen afvangen, resources opschonen (vaak met using), betekenisvolle aangepaste exceptions maken, en fouten niet zwijgend negeren.
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)
}
Vang specifieke exception-typen eerst af, gebruik Exception als laatste catch-all, en finally voor opruiming die altijd moet plaatsvinden. Belangrijk: gebruik throw; (niet throw ex;) om opnieuw te gooien — dit behoudt de originele stack trace.
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
De using statement zorgt ervoor dat IDisposable resources (bestanden, verbindingen) correct worden verwijderd — de voorkeurmanier om resource cleanup af te handelen, betrouwbaarder dan handmatige finally.
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
Goed exception handling is essentieel voor het bouwen van robuuste, betrouwbare C# applicaties, dus het grondig begrijpen ervan is belangrijk.
De try/catch/finally structuur, het afvangen van specifieke exception-typen (voor gerichte afhandeling) met Exception als laatste catch-all, en finally voor gegarandeerde opruiming zijn fundamenteel.
Meerdere C#-specifieke best practices zijn bijzonder belangrijk: throw; in plaats van throw ex; gebruiken bij opnieuw gooien (een subtiel maar cruciaal detail — throw ex; stelt de stack trace opnieuw in, waardoor waardevolle debug-informatie verloren gaat), de using statement gebruiken voor IDisposable resources (de voorkeur, betrouwbare manier om ervoor te zorgen dat bestanden, verbindingen en andere resources correct worden opgeruimd, zelfs wanneer exceptions optreden — robuuster dan handmatige finally blokken, en centraal voor C#'s resource-management model), en exceptions niet zwijgend negeren.
Exception handling begrijpen — de structuur, specifieke afvangsten, aangepaste exceptions, de stack-trace-behoudende opnieuw gooien, en vooral using voor resource cleanup — is belangrijk voor het schrijven van betrouwbare C# die fouten netjes afhandelt en resources correct beheert.
Aangezien onafgehandelde exceptions en resource leaks echte betrouwbaarheidsproblemen veroorzaken, en aangezien C# specifieke idiomen heeft (het using patroon, throw; behoud) die robuuste code van fragiele code onderscheiden, is het beheersen van exception handling belangrijk, veelgebruikt kennis voor professionele C# ontwikkeling.