Manejo de excepciones en C#

Una excepción se define como un evento que ocurre durante la ejecución de un programa que no es esperado por el código del programa. Las acciones a realizar en caso de ocurrencia de una excepción no son conocidas por el programa. En tal caso, creamos un objeto de excepción y llamamos al código del controlador de excepciones. La ejecución de un controlador de excepciones para que el código del programa no falle se denomina manejo de excepciones. El manejo de excepciones es importante porque maneja con gracia un evento no deseado, una excepción para que el código del programa aún tenga sentido para el usuario.
 

Tomemos un ejemplo simple para entender qué es una excepción:
 

// C# program to show how
// Exceptions occur in a program
using System;
 
class GFG {
 
    static void Main(string[] args)
    {
        // Declare an array of max index 4
        int[] arr = { 1, 2, 3, 4, 5 };
 
        // Display values of array elements
        for (int i = 0; i < arr.Length; i++) {
            Console.WriteLine(arr[i]);
        }
 
        // Try to access invalid index of array
        Console.WriteLine(arr[7]);
        // An exception is thrown upon executing
        // the above line
    }
}

Error de tiempo de ejecución:
 

Excepción no controlada: 
System.IndexOutOfRangeException: el índice estaba fuera de los límites de la array. 
en GFG.Main (System.String[] args) [0x0002e] en <9fa39b3b4dec49eb8af89dc70d5a0618>:0 
[ERROR] EXCEPCIÓN FATAL NO MANEJADA: System.IndexOutOfRangeException: el índice estaba fuera de los límites de la array. 
en GFG.Main (System.String[] argumentos) [0x0002e] en <9fa39b3b4dec49eb8af89dc70d5a0618>:0 
 

Producción:
 

1
2
3
4
5

En el código anterior, la array denominada ‘arr’ se define para 5 elementos, índices 0 a 4. Cuando intentamos acceder al séptimo elemento de la array, que no existe, el código del programa arroja una excepción y el mensaje anterior se visualiza. La excepción se puede controlar mediante la clase System.Exception de C#. Esto se representará en el código que se proporciona a continuación.
 

Manejo de excepciones usando el bloque try-catch

El código que se muestra a continuación muestra cómo podemos manejar las excepciones usando el bloque try-catch. El código que puede generar una excepción se coloca dentro del bloque de prueba. En este caso, el acceso al 7º elemento se coloca dentro del bloque try. Cuando se ejecuta esa declaración, se genera una excepción, que es capturada por el bloque catch. El objeto del tipo IndexOutOfRangeException se utiliza para mostrar un mensaje al usuario sobre la excepción que se ha producido.
Sintaxis:
 

try
{
  // statements that may cause an exception
}
catch( Exception obj)
{
  // handler code
}

// Exception handling of above code
// using try catch blocks
 
using System;
 
class Program : System.Exception {
    static void Main(string[] args)
    {
        // Declare an array of max index 4
        int[] arr = { 1, 2, 3, 4, 5 };
 
        // Display values of array elements
        for (int i = 0; i < arr.Length; i++) {
            Console.WriteLine(arr[i]);
        }
 
        try {
 
            // Try to access invalid index of array
            Console.WriteLine(arr[7]);
            // An exception is thrown upon executing
            // the above line
        }
        catch (IndexOutOfRangeException e) {
 
            // The Message property of the object
            // of type IndexOutOfRangeException
            // is used to display the type of exception
            // that has occurred to the user.
            Console.WriteLine("An Exception has occurred : {0}", e.Message);
        }
    }
}

Producción:
 

1
2
3
4
5
An Exception has occurred : Index was outside the bounds of the array.

Uso de múltiples bloques de intento y captura

En el código que se proporciona a continuación, intentamos generar una excepción en el bloque de prueba y atraparla en uno de los múltiples bloques de captura. Se utilizan varios bloques catch cuando no estamos seguros del tipo de excepción que se puede generar, por lo que escribimos diferentes bloques para abordar cualquier tipo de excepción que se encuentre. 
El bloque finalmente es la parte del código que debe ejecutarse independientemente de si la excepción se generó o no. En el programa que se muestra a continuación, los elementos de la array se muestran en el bloque finalmente.
Sintaxis:
 

try
{
  // statements that may cause an exception
}
catch(Specific_Exception_type obj)
{
  // handler code
}
catch(Specific_Exception_type obj)
{
  // handler code
}
.
.
.
finally
{
  //default code
}

// C# Program to show use of
// multiple try catch blocks
using System;
 
class Program {
 
    static void Main(string[] args)
    {
        int[] arr = {19, 0, 75, 52};
 
        try {
 
            // Try to generate an exception
            for (int i = 0; i < arr.Length; i++) {
                Console.WriteLine(arr[i] / arr[i + 1]);
            }
        }
 
        // Catch block for invalid array access
        catch (IndexOutOfRangeException e) {
 
            Console.WriteLine("An Exception has occurred : {0}", e.Message);
        }
 
        // Catch block for attempt to divide by zero
        catch (DivideByZeroException e) {
 
            Console.WriteLine("An Exception has occurred : {0}", e.Message);
        }
 
        // Catch block for value being out of range
        catch (ArgumentOutOfRangeException e) {
 
            Console.WriteLine("An Exception has occurred : {0}", e.Message);
        }
 
        // Finally block
        // Will execute irrespective of the above catch blocks
        finally {
            for (int i = 0; i < arr.Length; i++) {
                Console.Write(" {0}", arr[i]);
            }
        }
    }
}

Producción: 
 

An Exception has occurred : Attempted to divide by zero.
 19 0 75 52

Excepciones definidas por el usuario

Las excepciones definidas por el usuario son útiles cuando queremos codificar una excepción que puede no estar definida por el lenguaje. Por ejemplo, en una sala de calderas, si la temperatura sube por encima de cierto umbral, entonces se debe apagar la calefacción. Para comprender cómo se utilizan las excepciones definidas por el usuario, tomamos un ejemplo de una división por cero. Aquí definimos una clase DivByZero que hereda de Exception y es llamada por la función DivisionOperation cuando el denominador es igual a cero. Dado que la llamada a la función puede arrojar o no una excepción, se coloca en el bloque de prueba. Se define un bloque catch para capturar cualquier excepción de tipo Exception y la propiedad Message imprime el tipo de excepción que se ha producido.
 

// C# program to show the user defined exceptions
using System;
 
// User defined Exception class
// Child of Exception
class DivByZero : Exception {
 
    // Constructor
    public DivByZero()
    {
        Console.Write("Exception has occurred : ");
    }
}
 
class Program {
 
    // Method to perform Division
    public double DivisionOperation(double numerator,
                                 double denominator)
    {
        // throw exception when denominator
        // value is 0
        if (denominator == 0)
            throw new DivByZero();
 
        // Otherwise return the result of the division
        return numerator / denominator;
    }
 
    // Main
    static void Main(string[] args)
    {
        Program obj = new Program();
        double num = 9, den = 0, quotient;
        try {
            // Code block that may cause an exception
            quotient = obj.DivisionOperation(num, den);
            Console.WriteLine("Quotient = {0}", quotient);
        }
        // Catch block to catch the generic exception
        catch (Exception e) {
            // Message property of exception object e
            // will give the specific type of the exception
            Console.Write(e.Message);
        }
    }
}

Producción: 
 

Exception has occurred : Exception of type 'DivByZero' was thrown.