Cómo capturar múltiples excepciones en C#: guía completa

Capturar de una vez: cómo interceptar múltiples excepciones en C# sin duplicar código

Imagine: está escribiendo una aplicación que trabaja con archivos, red y bases de datos. En un solo método pueden lanzarse FileNotFoundException, IOException o UnauthorizedAccessException. El enfoque clásico — tres bloques catch con el mismo código dentro. Esto viola el principio DRY (Don't Repeat Yourself) y convierte el código en "espagueti".

La buena noticia: en C# existen varias formas elegantes de capturar múltiples excepciones a la vez. En este tutorial analizaremos todas las opciones — desde las básicas hasta las avanzadas — y aprenderá a escribir código de manejo de errores limpio y mantenible.

¿Por qué es importante? Un escenario real

Supongamos que desarrolla una aplicación de consola para copias de seguridad. Lee archivos, los comprime y los envía a un servidor remoto. En cada etapa pueden surgir diferentes excepciones:

\n
• Lectura de archivo: FileNotFoundException, PathTooLongException
\n
• Compresión: OutOfMemoryException
\n
• Envío: HttpRequestException, TimeoutException
\n

Si escribe un catch separado para cada excepción con el mismo registro, el código se volverá voluminoso. Y si luego necesita cambiar la lógica — tendrá que modificar en tres lugares. Aquí es donde resulta útil saber capturar varias excepciones a la vez.

Método 1. Clásico: múltiples bloques catch (antes de C# 6)

El método más simple y obvio — escribir varios bloques catch en secuencia. C# seleccionará automáticamente el bloque adecuado según el tipo de excepción:

try\n{\n    // Código que puede lanzar diferentes excepciones\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($"Archivo no encontrado: {ex.Message}");\n    LogError(ex);\n}\ncatch (FormatException ex)\n{\n    Console.WriteLine($"Formato de datos incorrecto: {ex.Message}");\n    LogError(ex);\n}\ncatch (HttpRequestException ex)\n{\n    Console.WriteLine($"Error de red: {ex.Message}");\n    LogError(ex);\n}

Ventajas: transparente, fácil de leer, se puede manejar cada excepción de forma diferente.
\nDesventajas: si las acciones son iguales — duplicación de código.

Método 2. Capturar múltiples excepciones en un solo catch (C# 6+)

A partir de C# 6, puede enumerar varios tipos de excepciones usando | en un solo bloque catch. Esto reduce la duplicación y mantiene la legibilidad:

try\n{\n    // Código riesgoso\n}\ncatch (FileNotFoundException | FormatException | HttpRequestException ex)\n{\n    Console.WriteLine($"Ocurrió un error: {ex.Message}");\n    LogError(ex);\n    // Lógica adicional, común para los tres tipos\n}

Importante: todas las excepciones deben ser compatibles en jerarquía. No se pueden mezclar, por ejemplo, IOException y NullReferenceException — no están relacionadas por un ancestro común, excepto Exception. Pero en C# 6+ esto está permitido, el compilador simplemente convertirá la variable ex al tipo base común.

¿Cuándo usar este método?

\n
• Cuando la lógica de manejo es idéntica para todas las excepciones.
\n
• Cuando desea evitar bloques if o switch anidados.
\n
• En métodos pequeños, donde la brevedad es importante.
\n

Método 3. Filtros de excepciones (C# 6+)

Los filtros de excepciones son un mecanismo potente que permite capturar excepciones según una condición usando la palabra clave when. Puede interceptar la misma excepción, pero con diferente lógica según sus propiedades:

try\n{