Mehrere Exceptions in C# abfangen: Komplettguide

Auf einen Schlag fangen: So fängst du mehrere Exceptions in C# ohne Code-Duplizierung

Stell dir vor: Du entwickelst eine Anwendung, die mit Dateien, Netzwerk und Datenbanken arbeitet. In einer einzigen Methode können FileNotFoundException, IOException oder UnauthorizedAccessException auftreten. Der klassische Ansatz – drei catch-Blöcke mit identischem Code – verletzt das DRY-Prinzip (Don't Repeat Yourself) und verwandelt deinen Code in "Spaghetti".

Die gute Nachricht: In C# gibt es mehrere elegante Wege, mehrere Exceptions auf einmal abzufangen. In diesem Tutorial zeigen wir dir alle Varianten – von den Grundlagen bis zu fortgeschrittenen Techniken – und du lernst, wie du sauberen, wartbaren Code für die Fehlerbehandlung schreibst.

Warum ist das wichtig? Ein realistisches Szenario

Angenommen, du entwickelst eine Konsolenanwendung für Backups. Sie liest Dateien, komprimiert sie und sendet sie an einen entfernten Server. In jeder Phase können unterschiedliche Exceptions auftreten:

\n
• Datei lesen: FileNotFoundException, PathTooLongException
\n
• Komprimierung: OutOfMemoryException
\n
• Senden: HttpRequestException, TimeoutException
\n

Wenn du für jede Exception einen separaten catch-Block mit identischer Logging-Logik schreibst, wird der Code schnell unübersichtlich. Und wenn du später die Logik ändern musst, musst du sie an drei Stellen anpassen. Genau hier kommt die Fähigkeit, mehrere Exceptions auf einmal abzufangen, ins Spiel.

Methode 1: Klassisch – Mehrere catch-Blöcke (vor C# 6)

Die einfachste und offensichtlichste Methode ist, mehrere catch-Blöcke hintereinander zu schreiben. C# wählt automatisch den passenden Block basierend auf dem Exception-Typ aus:

try\n{\n    // Code, der verschiedene Exceptions auslösen kann\n    string content = File.ReadAllText(@"C:\\data\\config.txt");\n    int value = int.Parse(content);\n    await SendToServerAsync(value);\n}\ncatch (FileNotFoundException ex)\n{\n    Console.WriteLine($"Datei nicht gefunden: {ex.Message}");\n    LogError(ex);\n}\ncatch (FormatException ex)\n{\n    Console.WriteLine($"Ungültiges Datenformat: {ex.Message}");\n    LogError(ex);\n}\ncatch (HttpRequestException ex)\n{\n    Console.WriteLine($"Netzwerkfehler: {ex.Message}");\n    LogError(ex);\n}

Vorteile: transparent, leicht lesbar, jede Exception kann individuell behandelt werden.
\nNachteile: Bei identischen Aktionen führt es zu Code-Duplizierung.

Methode 2: Mehrere Exceptions in einem catch abfangen (C# 6+)

Seit C# 6 kannst du mehrere Exception-Typen mit | in einem einzigen catch-Block auflisten. Das reduziert Duplizierung und bleibt dennoch lesbar:

try\n{\n    // Riskanter Code\n}\ncatch (FileNotFoundException | FormatException | HttpRequestException ex)\n{\n    Console.WriteLine($"Ein Fehler ist aufgetreten: {ex.Message}");\n    LogError(ex);\n    // Zusätzliche Logik, die für alle drei Typen gilt\n}

Wichtig: Alle Exceptions müssen hierarchisch kompatibel sein. Du kannst z. B. IOException und NullReferenceException nicht mischen – sie haben außer Exception keinen gemeinsamen Vorfahren. In C# 6+ ist das jedoch erlaubt; der Compiler wandelt die Variable ex einfach in den gemeinsamen Basistyp um.

Wann solltest du diese Methode verwenden?

\n
• Wenn die Behandlungslogik für alle Exceptions identisch ist.
\n
• Wenn du verschachtelte if- oder switch-Blöcke vermeiden möchtest.
\n
• In kleinen Methoden, bei denen Kürze wichtig ist.
\n

Methode 3: Exception-Filter (C# 6+)

Exception-Filter sind ein mächtiges Werkzeug, mit dem du Exceptions basierend auf einer Bedingung mit dem Schlüsselwort when abfangen kannst. Du kannst dieselbe Exception abfangen, aber je nach ihren Eigenschaften unterschiedliche Logik anwenden:

try\n{