C # - Manejo de excepciones

Una excepción es un problema que surge durante la ejecución de un programa. La excepción AC # es una respuesta a una circunstancia excepcional que surge mientras se ejecuta un programa, como un intento de dividir por cero.

Las excepciones proporcionan una forma de transferir el control de una parte de un programa a otra. El manejo de excepciones de C # se basa en cuatro palabras clave:try, catch, finallyy throw.

  • try- Un bloque try identifica un bloque de código para el que se activan excepciones particulares. Le sigue uno o más bloques de captura.

  • catch- Un programa detecta una excepción con un manejador de excepciones en el lugar de un programa donde desea manejar el problema. La palabra clave catch indica la captura de una excepción.

  • finally- El bloque finalmente se usa para ejecutar un conjunto dado de declaraciones, tanto si se lanza una excepción como si no. Por ejemplo, si abre un archivo, debe cerrarse tanto si se genera una excepción como si no.

  • throw- Un programa lanza una excepción cuando aparece un problema. Esto se hace usando una palabra clave de lanzamiento.

Sintaxis

Suponiendo que un bloque genera una excepción, un método detecta una excepción utilizando una combinación de las palabras clave try y catch. Se coloca un bloque try / catch alrededor del código que podría generar una excepción. El código dentro de un bloque try / catch se conoce como código protegido, y la sintaxis para usar try / catch es similar a la siguiente:

try {
   // statements causing exception
} catch( ExceptionName e1 ) {
   // error handling code
} catch( ExceptionName e2 ) {
   // error handling code
} catch( ExceptionName eN ) {
   // error handling code
} finally {
   // statements to be executed
}

Puede enumerar varias declaraciones de captura para detectar diferentes tipos de excepciones en caso de que su bloque try genere más de una excepción en diferentes situaciones.

Clases de excepción en C #

Las excepciones de C # están representadas por clases. Las clases de excepción en C # se derivan principalmente directa o indirectamente delSystem.Exceptionclase. Algunas de las clases de excepción derivadas de la clase System.Exception son lasSystem.ApplicationException y System.SystemException clases.

los System.ApplicationExceptionLa clase admite excepciones generadas por programas de aplicación. Por tanto, las excepciones definidas por los programadores deberían derivar de esta clase.

los System.SystemException class es la clase base para todas las excepciones predefinidas del sistema.

La siguiente tabla proporciona algunas de las clases de excepción predefinidas derivadas de la clase Sytem.SystemException:

No Señor. Clase de excepción y descripción
1

System.IO.IOException

Maneja errores de E / S.

2

System.IndexOutOfRangeException

Maneja errores generados cuando un método hace referencia a un índice de matriz fuera de rango.

3

System.ArrayTypeMismatchException

Maneja los errores generados cuando el tipo no coincide con el tipo de matriz.

4

System.NullReferenceException

Maneja errores generados al hacer referencia a un objeto nulo.

5

System.DivideByZeroException

Maneja los errores generados al dividir un dividendo con cero.

6

System.InvalidCastException

Maneja errores generados durante el encasillado.

7

System.OutOfMemoryException

Maneja errores generados por memoria libre insuficiente.

8

System.StackOverflowException

Maneja los errores generados por el desbordamiento de la pila.

Manejo de excepciones

C # proporciona una solución estructurada para el manejo de excepciones en forma de bloques try y catch. Al usar estos bloques, las declaraciones del programa principal se separan de las declaraciones de manejo de errores.

Estos bloques de manejo de errores se implementan usando el try, catchy finallypalabras clave. A continuación se muestra un ejemplo de cómo lanzar una excepción cuando se produce una condición de división por cero:

using System;

namespace ErrorHandlingApplication {
   class DivNumbers {
      int result;
      
      DivNumbers() {
         result = 0;
      }
      public void division(int num1, int num2) {
         try {
            result = num1 / num2;
         } catch (DivideByZeroException e) {
            Console.WriteLine("Exception caught: {0}", e);
         } finally {
            Console.WriteLine("Result: {0}", result);
         }
      }
      static void Main(string[] args) {
         DivNumbers d = new DivNumbers();
         d.division(25, 0);
         Console.ReadKey();
      }
   }
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Exception caught: System.DivideByZeroException: Attempted to divide by zero. 
at ...
Result: 0

Creación de excepciones definidas por el usuario

También puede definir su propia excepción. Las clases de excepciones definidas por el usuario se derivan de laExceptionclase. El siguiente ejemplo demuestra esto:

using System;

namespace UserDefinedException {
   class TestTemperature {
      static void Main(string[] args) {
         Temperature temp = new Temperature();
         try {
            temp.showTemp();
         } catch(TempIsZeroException e) {
            Console.WriteLine("TempIsZeroException: {0}", e.Message);
         }
         Console.ReadKey();
      }
   }
}
public class TempIsZeroException: Exception {
   public TempIsZeroException(string message): base(message) {
   }
}
public class Temperature {
   int temperature = 0;
   
   public void showTemp() {
      
      if(temperature == 0) {
         throw (new TempIsZeroException("Zero Temperature found"));
      } else {
         Console.WriteLine("Temperature: {0}", temperature);
      }
   }
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

TempIsZeroException: Zero Temperature found

Lanzar objetos

Puede lanzar un objeto si se deriva directa o indirectamente de la System.Exceptionclase. Puede usar una instrucción throw en el bloque catch para lanzar el objeto presente como:

Catch(Exception e) {
   ...
   Throw e
}