Tutorial CSharp: Excepciones

Una excepción es una respuesta a una condición excepcional que requiere acción inmediata. Es la forma que tiene un programa de indicar que se ha producido un error durante la ejecución.

El manejo de excepciones es un mecanismo que permite separar el código que resuelve problemas y errores del resto del programa. En lugar de tener código de comprobación de errores esparcido por todas partes, se agrupan los errores en bloques y se gestiona de forma organizada.

En C#, la clase base de todas las excepciones es la clase Exception. Esta clase define varias propiedades y métodos que son comunes a todas las excepciones.

Bloques try y catch

La gestión de errores se realiza principalmente mediante los bloques try y catch. El bloque try contendrá el código que es susceptible de lanzar un error, y el bloque catch indicará que hacer si se lanza una excepción.

Un ejemplo sencillo en el que se lanza y se captura una excepción sería:

try
{
    int x = 0;
    int y = 5;
    int z = y / x;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Se ha intentado dividir por cero: " + ex.Message);
}

En este código, se ha colocado el código que puede lanzar una excepción dentro de un bloque try. Si ocurre una excepción en este bloque, el control se transfiere al bloque catch correspondiente.

En este caso, se intenta dividir por cero, lo que lanza una DivideByZeroException. Esta excepción se captura en el bloque catch y se muestra un mensaje de error.

Tipos de Excepciones

En C#, hay una variedad de clases de excepciones que se derivan de la clase Exception. Algunas de las más comunes son:

• DivideByZeroException: lanzada cuando se intenta dividir por cero.
• ArgumentNullException: lanzada cuando un argumento null se pasa a un método que no acepta null como argumento válido.
• ArgumentOutOfRangeException: lanzada cuando el valor de un argumento está fuera del rango de valores permitidos.
• InvalidOperationException: lanzada cuando se intenta realizar una operación que no es válida en el estado actual del objeto.

Por ejemplo, para lanzar y capturar una ArgumentOutOfRangeException:

try
{
    List<int> numeros = new List<int> {1, 2, 3};
    Console.WriteLine(numeros[3]);
}
catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine("El índice está fuera del rango de la lista: " + ex.Message);
}

En este caso, se intenta acceder al cuarto elemento de una lista que sólo tiene tres elementos. Esto lanza una ArgumentOutOfRangeException, que puede capturarse para mostrar un mensaje de error.

Uso de múltiples bloques catch

En C#, es posible usar varios bloques catch uno tras otro para capturar diferentes tipos de excepciones. Esto es útil cuando el bloque de código dentro del try puede lanzar más de un tipo de excepción y deseas manejar cada tipo de excepción de manera diferente.

Por ejemplo:

try
{
    // Código que puede lanzar diferentes tipos de excepciones
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Se ha intentado dividir por cero: " + ex.Message);
}
catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine("El índice está fuera del rango de la lista: " + ex.Message);
}
catch (Exception ex)
{
    Console.WriteLine("Ocurrió una excepción: " + ex.Message);
}

En este caso, si el código dentro del bloque try lanza una DivideByZeroException o una ArgumentOutOfRangeException, el control se transfiere al bloque catch correspondiente.

El último bloque catch en el ejemplo anterior captura cualquier excepción que herede de la clase Exception. Esto incluye todas las excepciones en C#, ya que todas las excepciones en C# heredan de la clase Exception. Este bloque catch captura cualquier excepción que no haya sido capturada por los bloques catch anteriores.

Es importante destacar que el orden de los bloques catch importa. El compilador evalúa los bloques catch de arriba a abajo, y sólo la primera coincidencia se ejecuta. Por lo tanto, el bloque catch más general (en este caso, el que captura la clase base Exception) debe ir siempre al final. De lo contrario, las excepciones más específicas nunca serían capturadas por sus bloques catch correspondientes, ya que la excepción general las capturaría primero.

Creación y lanzamiento de excepciones personalizadas

Es posible que sea necesario crear tus propias excepciones para manejar situaciones específicas en el código. Para hacer esto, puede crearse una clase que se derive de Exception.

public class MiExcepcion : Exception
{
    public MiExcepcion(string message) : base(message)
    {
    }
}

A continuación, puede lanzarse esta excepción personalizada en el código usando la palabra clave throw, como con cualquier otra excepción.

try
{
    throw new MiExcepcion("Ha ocurrido un error personalizado");
}
catch (MiExcepcion ex)
{
    Console.WriteLine(ex.Message);
}

En este ejemplo, se crea una nueva excepción llamada MiExcepcion y se lanza con un mensaje personalizado. Luego, se captura la excepción en un bloque catch y se muestra el mensaje.

Bloques finally

Además de try y catch, también puede usarse un bloque finally en el manejo de excepciones. El código dentro de un bloque finally se ejecutará siempre, independientemente de si se lanza una excepción o no.

try
{
    int x = 0;
    int y = 5;
    int z = y / x;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Se ha intentado dividir por cero: " + ex.Message);
}
finally
{
    Console.WriteLine("Este mensaje se muestra siempre, ocurra o no la excepción.");
}

En este código, después de que el bloque try o catch se ejecutan, se ejecuta el bloque finally y se muestra el mensaje en la consola. Esto es útil para código que debe ejecutarse independientemente de si se produce un error, como la limpieza de recursos.

En resumen, el manejo de excepciones en C# es un mecanismo poderoso para controlar los errores durante la ejecución de un programa y asegurarse de que los recursos se limpien adecuadamente.