C# Exception Handling: try, catch, finally, throw & Best Practices

• try – Block, der überwacht wird.
• catch – Behandelt eine bestimmte Exception.
• finally – Wird immer ausgeführt (Cleanup).
• throw – Löst Exception explizit aus.

Syntax

try
{
    // Code, der Exception werfen kann
}
catch (SpecificException ex)
{
    // Behandlung für SpecificException
}
catch (AnotherException ex)
{
    // Behandlung für AnotherException
}
catch (Exception ex) // Basistyp zuletzt
{
    // Generische Behandlung
}
finally
{
    // Cleanup (Dateien schließen, Locks freigeben, etc.)
}

Wichtige Exception-Klassen

Alle Exceptions erben von System.Exception. Wichtige vordefinierte Typen:

Beispiel: Division durch Null abfangen

using System;

public class Divider
{
    public void Divide(int a, int b)
    {
        try
        {
            int result = a / b;
            Console.WriteLine($"Result: {result}");
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine($"Fehler: {ex.Message}");
        }
        finally
        {
            Console.WriteLine("Operation abgeschlossen.");
        }
    }
}

// Nutzung
new Divider().Divide(10, 0);
// Ausgabe:
// Fehler: Attempted to divide by zero.
// Operation abgeschlossen.

Eigene Exceptions definieren

Ableitung von Exception (oder ApplicationException für anwendungsspezifische).

[Serializable]
public class TemperatureZeroException : Exception
{
    public TemperatureZeroException() { }
    public TemperatureZeroException(string message) : base(message) { }
    public TemperatureZeroException(string message, Exception inner) : base(message, inner) { }
    protected TemperatureZeroException(SerializationInfo info, StreamingContext context) : base(info, context) { }
}

// Verwendung
public class Temperature
{
    public int Value { get; set; }
    public void Check()
    {
        if (Value == 0) throw new TemperatureZeroException("Temperatur darf nicht Null sein.");
    }
}

Best Practices

• Nur fangen, was Sie behandeln können – nicht catch (Exception) ohne Grund.
• Nicht für Steuerfluss nutzen – Exceptions sind teuer.
• finally / using / IDisposable für Ressourcen-Cleanup.
• Original-Exception beim Weiterwerfen erhalten: throw; (nicht throw ex; – Stack Trace geht verloren).
• Benutzerdefinierte Exceptions mit [Serializable] und Konstruktoren nach Muster.
• ArgumentNullException etc. für Validierung in öffentlichen APIs werfen.