¿Cómo capturar excepciones específicas en C#?

Capturar excepciones es una práctica fundamental en el desarrollo de software para manejar errores y evitar que tu aplicación falle inesperadamente. En C#, puedes capturar excepciones específicas utilizando bloques try-catch. Esto te permite manejar diferentes tipos de excepciones de manera controlada y realizar acciones correctivas según el tipo de error que ocurra.

Uso básico de try-catch

En su forma más básica, un bloque try-catch se utiliza para envolver el código que puede lanzar una excepción. Si una excepción es lanzada dentro del bloque try, se busca un bloque catch correspondiente que pueda manejarla.

try
{
    // Código que puede lanzar una excepción
    int result = 10 / int.Parse("0");
}
catch (Exception ex)
{
    // Manejo de excepciones
    Console.WriteLine("Ocurrió un error: " + ex.Message);
}

En este ejemplo, estamos intentando dividir un número por cero, lo cual lanzará una excepción DivideByZeroException. Si bien este código captura la excepción, no estamos capturando un tipo específico de excepción.

Capturando excepciones específicas

Es posible capturar excepciones específicas para manejar diferentes errores de manera particular. Para ello, puedes añadir múltiples bloques catch, cada uno diseñado para un tipo de excepción en particular.

try
{
    // Código que puede lanzar varias excepciones
    int[] numbers = { 1, 2, 3 };
    int result = 10 / int.Parse("0");
    Console.WriteLine(numbers[10]);
}
catch (DivideByZeroException ex)
{
    // Manejo de división por cero
    Console.WriteLine("Error: No se puede dividir por cero.");
}
catch (IndexOutOfRangeException ex)
{
    // Manejo de acceso a un índice fuera del rango
    Console.WriteLine("Error: Índice fuera de rango.");
}
catch (Exception ex)
{
    // Manejo de cualquier otra excepción
    Console.WriteLine("Ocurrió un error: " + ex.Message);
}

En este ejemplo, hemos añadido bloques catch específicos para DivideByZeroException y IndexOutOfRangeException. El bloque catch general al final captura cualquier otra excepción que no haya sido manejada por los bloques específicos anteriores.

Orden de los bloques catch

Es importante que los bloques catch específicos se coloquen antes que los bloques catch más generales. Si colocas un bloque catch general primero, las excepciones específicas nunca serán capturadas, ya que el bloque general las manejará primero.

try
{
    // Código que puede lanzar una excepción
}
catch (Exception ex)
{
    // Este bloque capturará todas las excepciones
    Console.WriteLine("Ocurrió un error: " + ex.Message);
}
catch (DivideByZeroException ex)
{
    // Este bloque nunca se ejecutará
    Console.WriteLine("Error: No se puede dividir por cero.");
}

El código anterior no es correcto ya que el bloque catch para DivideByZeroException nunca se ejecutará. Es crucial colocar los bloques más específicos antes de los más generales.

Conclusión

Capturar excepciones específicas en C# te permite manejar errores de manera más precisa y realizar acciones correctivas basadas en el tipo de error. Utilizando múltiples bloques catch, puedes capturar y manejar diferentes excepciones de forma controlada, mejorando la robustez y fiabilidad de tu aplicación. Recuerda siempre colocar los bloques catch más específicos antes de los más generales para asegurar que las excepciones sean manejadas correctamente.