CSharp: Excepciones

El manejo de excepciones es crucial para construir aplicaciones robustas en C#. Una excepción es un evento que ocurre durante la ejecución de un programa y que interrumpe el flujo normal de instrucciones. En C#, todas las excepciones derivan de la clase base System.Exception.

Captura y manejo de excepciones

La estructura básica para capturar y manejar excepciones en C# es mediante los bloques try, catch y finally.

try
{
    // Código que puede generar una excepción
}
catch (Exception ex)
{
    // Manejo de la excepción
    Console.WriteLine($"Ocurrió un error: {ex.Message}");
}
finally
{
    // Código que siempre se ejecuta, haya o no excepción
}

Tipos de excepciones comunes

En C#, existen varios tipos de excepciones predefinidas que se pueden manejar de manera específica:

• ArgumentException: se lanza cuando un argumento proporcionado a un método no es válido.
• NullReferenceException: se lanza cuando se intenta utilizar una referencia de objeto que no ha sido inicializada.
• InvalidOperationException: se lanza cuando el estado actual de un objeto no permite la operación solicitada.

Creación de excepciones personalizadas

En ocasiones, es necesario definir excepciones personalizadas para representar errores específicos de la lógica de negocio. Para ello, se debe crear una clase que derive de System.Exception.

public class MiExcepcionPersonalizada : Exception
{
    public MiExcepcionPersonalizada()
    {
    }

    public MiExcepcionPersonalizada(string mensaje)
        : base(mensaje)
    {
    }

    public MiExcepcionPersonalizada(string mensaje, Exception inner)
        : base(mensaje, inner)
    {
    }
}

Propagación de excepciones

Las excepciones pueden propagarse a lo largo de la pila de llamadas hasta que sean capturadas y manejadas. Si una excepción no es capturada en un nivel, se propaga al nivel superior.

public void MetodoA()
{
    try
    {
        MetodoB();
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Excepción capturada en MetodoA: {ex.Message}");
    }
}

public void MetodoB()
{
    throw new InvalidOperationException("Error en MetodoB");
}

Usar excepciones de manera eficiente

El uso eficiente de excepciones implica no abusar de ellas para el control de flujo normal del programa. Las excepciones deben utilizarse para condiciones excepcionales y no como una alternativa a las estructuras de control de flujo estándar.

Bloques finally

El bloque finally permite ejecutar código de limpieza independientemente de si se produjo una excepción o no. Es útil para liberar recursos no administrados como conexiones a bases de datos o archivos.

FileStream fs = null;
try
{
    fs = new FileStream("archivo.txt", FileMode.Open);
    // Operaciones con el archivo
}
catch (IOException ex)
{
    Console.WriteLine($"Error de E/S: {ex.Message}");
}
finally
{
    if (fs != null)
        fs.Close();
}

Excepciones asincrónicas

En el contexto de programación asincrónica con async y await, las excepciones se manejan de forma similar a los métodos sincrónicos.

public async Task MetodoAsincrono()
{
    try
    {
        await Task.Run(() => { throw new InvalidOperationException("Error en tarea asincrónica"); });
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Excepción capturada en MetodoAsincrono: {ex.Message}");
    }
}