C# behandelt Fehler mit Exceptions, die über try/catch/finally abgefangen werden. Ordnungsgemäße Fehlerbehandlung bedeutet, spezifische Exception-Typen abzufangen, Ressourcen zu bereinigen (oft mit using), aussagekräftige benutzerdefinierte Exceptions zu erstellen und Fehler nicht stillschweigend zu ignorieren.
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)
}
Fangen Sie spezifische Exception-Typen zuerst ab, verwenden Sie Exception als finalen Fallback, und finally für Bereinigung, die immer ausgeführt werden muss. Wichtig: Verwenden Sie throw; (nicht throw ex;) zum Neuwerfen — das bewahrt die ursprüngliche 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
Das using-Statement stellt sicher, dass IDisposable-Ressourcen (Dateien, Verbindungen) ordnungsgemäß freigegeben werden — die bevorzugte Methode zur Ressourcenbereinigung, zuverlässiger als manuelles 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
Ordnungsgemäße Fehlerbehandlung ist wesentlich für die Erstellung robuster, zuverlässiger C#-Anwendungen, daher ist das gründliche Verständnis wichtig.
Die try/catch/finally-Struktur, das Abfangen spezifischer Exception-Typen (für gezielten Umgang) mit Exception als finalen Fallback und finally für garantierte Bereinigung sind grundlegend.
Mehrere C#-spezifische Best Practices sind besonders wichtig: Verwendung von throw; statt throw ex; beim Neuwerfen (ein subtiles, aber entscheidendes Detail — throw ex; setzt die Stack Trace zurück und verliert wertvolle Debugging-Informationen), Verwendung des using-Statements für IDisposable-Ressourcen (die bevorzugte, zuverlässige Methode, um sicherzustellen, dass Dateien, Verbindungen und andere Ressourcen ordnungsgemäß freigegeben werden, auch wenn Exceptions auftreten — robuster als manuelle finally-Blöcke und zentral für C#s Ressourcenverwaltungsmodell) und das Vermeiden, Exceptions stillschweigend zu ignorieren.
Verständnis der Fehlerbehandlung — die Struktur, spezifische Catches, benutzerdefinierte Exceptions, das Stack-Trace-erhaltende Neuwerfen und besonders using für Ressourcenbereinigung — ist wichtig für das Schreiben von zuverlässigem C#, das Fehler elegant behandelt und Ressourcen korrekt verwaltet.
Da unbehandelte Exceptions und Ressourcenlecks echte Zuverlässigkeitsprobleme verursachen und da C# spezifische Idiome hat (das using-Pattern, throw;-Erhaltung), die robusten Code von fragilem Code unterscheiden, ist die Beherrschung der Fehlerbehandlung wichtiges, häufig angewendetes Wissen für professionelle C#-Entwicklung.