16.11. Orientación a objetos en C#: manejo de excepciones

La orientación a objetos en C# es un enfoque de programación que implica la creación de objetos que contienen datos y métodos. Una de las partes más importantes de la orientación a objetos en C# es el manejo de excepciones. Las excepciones son eventos que ocurren durante la ejecución de un programa que interrumpen el flujo normal del programa.

En C#, el manejo de excepciones se realiza principalmente mediante el uso de bloques try, catch y finalmente. El bloque try contiene código que podría causar una excepción. El bloque catch se utiliza para manejar la excepción si ocurre. El bloque finalmente contiene código que siempre se ejecuta, independientemente de si ocurre una excepción o no.

Comencemos con un ejemplo sencillo. Considere el siguiente código:

intentar
{
    int x = 0;
    int y = 5/x;
}
captura (DivideByZeroException e)
{
    Consola.WriteLine(e.Mensaje);
}
finalmente
{
    Console.WriteLine("Bloque finalmente ejecutado.");
}

En este ejemplo, intentamos dividir un número entre cero, lo que resultará en una excepción DivideByZeroException. Cuando se produce esta excepción, el control se pasa al bloque catch, que imprime el mensaje de excepción. Luego se ejecuta el bloque finalmente imprimiendo el mensaje "Finalmente bloque ejecutado".

Es importante tener en cuenta que el bloque catch solo se ejecutará si se lanza la excepción especificada. Si se lanza una excepción diferente, el bloque catch no se ejecutará. Por ejemplo, si cambiamos nuestro código a lo siguiente:

intentar
{
    int[] matriz = nuevo int[5];
    Console.WriteLine(matriz[5]);
}
captura (DivideByZeroException e)
{
    Consola.WriteLine(e.Mensaje);
}
finalmente
{
    Console.WriteLine("Bloque finalmente ejecutado.");
}

En este caso, se generará una excepción IndexOutOfRangeException, ya que estamos intentando acceder a un índice de matriz que no existe. Sin embargo, dado que nuestro bloque catch solo detecta excepciones de DivideByZeroException, esta excepción no se detectará y el programa se detendrá. Sin embargo, el bloque finalmente se seguirá ejecutando.

Para manejar diferentes tipos de excepciones, podemos tener múltiples bloques catch. Por ejemplo:

intentar
{
    // código que puede generar excepciones
}
captura (DivideByZeroException e)
{
    Console.WriteLine("Excepción de división por cero: " + e.Message);
}
captura (IndexOutOfRangeException e)
{
    Console.WriteLine("Excepción de índice fuera de rango: " + e.Message);
}
finalmente
{
    Console.WriteLine("Bloque finalmente ejecutado.");
}

En este caso, si se lanza una excepción DivideByZeroException o IndexOutOfRangeException, se detectará y manejará en consecuencia.

Además, podemos tener un bloque catch sin especificar un tipo de excepción. Este bloque catch detectará todas las excepciones que no fueron detectadas por los bloques catch anteriores. Por ejemplo:

intentar
{
    // código que puede generar excepciones
}
captura (DivideByZeroException e)
{
    Console.WriteLine("Excepción de división por cero: " + e.Message);
}
captura (IndexOutOfRangeException e)
{
    Console.WriteLine("Excepción de índice fuera de rango: " + e.Message);
}
captura (Excepción e)
{
    Console.WriteLine("Excepción genérica: " + e.Message);
}
finalmente
{
    Console.WriteLine("Bloque finalmente ejecutado.");
}

En este caso, si se lanza una excepción distinta de DivideByZeroException o IndexOutOfRangeException, será detectada por el bloque catch genérico.

En resumen, el manejo de excepciones es una parte importante de la orientación a objetos en C#, ya que nos permite lidiar con errores y excepciones de manera controlada, evitando que nuestro programa se detenga inesperadamente. Al utilizar los bloques try, catch y finalmente, podemos asegurarnos de que nuestro código sea sólido y confiable.

Siguiente página del libro electrónico gratuito:

28Orientación a objetos en C#: Colecciones en C#

3 minutos