Ejercicio: Implementación del control de excepciones try-catch

9 minutos

El try-catch patrón consta de un try bloque seguido de una o varias catch cláusulas. Cada catch cláusula especifica el controlador para un tipo de excepción diferente.

Cuando se produce una excepción, Common Language Runtime (CLR) busca una catch cláusula que pueda controlar la excepción. Si el método que se está ejecutando actualmente no contiene una catch cláusula que pueda controlar el tipo de excepción lanzado, el CLR busca en el método que invocó al método actual. La búsqueda continúa descendiendo por la pila de llamadas hasta que se encuentra una cláusula adecuada catch. Si no se encuentra ninguna catch cláusula para controlar la excepción, CLR muestra un mensaje de excepción no controlado al usuario y detiene la ejecución del programa.

En este ejercicio, implementarás un patrón básico try-catch.

Creación de un nuevo proyecto de código

El primer paso es crear un proyecto de código que use durante este módulo.

Abra una nueva instancia de Visual Studio Code.
En el menú Archivo , seleccione Abrir carpeta.
En el cuadro de diálogo Abrir carpeta , vaya a la carpeta escritorio de Windows.
En el cuadro de diálogo Abrir carpeta , seleccione Nueva carpeta.
Asigne el nombre Exceptions101 a la nueva carpeta y, a continuación, seleccione Seleccionar carpeta.
En el menú Terminal, seleccione Nuevo terminal.

Usará un comando de la CLI de .NET para crear una aplicación de consola.
En la línea de comandos del panel de terminal, escriba los siguientes comandos:
```
dotnet new console
```
Cierre el panel TERMINAL.

Implementación de un try-catch sencillo

Use la vista EXPLORADOR de Visual Studio Code para abrir el archivo Program.cs.
En el menú Vista, seleccione Paleta de comandos.
En el símbolo del sistema, escriba .net: g y, después, seleccione .NET: Generar recursos para compilar y depurar.

Reemplace el contenido del archivo Program.cs por el código siguiente:

double float1 = 3000.0;
double float2 = 0.0;
int number1 = 3000;
int number2 = 0;

Console.WriteLine(float1 / float2);
Console.WriteLine(number1 / number2);
Console.WriteLine("Exit program");

Dedique un minuto a examinar el código.

Observe que la aplicación usa dos tipos de variables numéricas y doubleint. El código realiza un cálculo de división mediante ambos tipos numéricos.

Los desarrolladores usan una double variable de tipo para los cálculos cuando los valores fraccionarios precisos son importantes.
En el menú Ejecutar, seleccione Iniciar depuración.

Observe que se produce una DivideByZeroException excepción al dividir los valores enteros.

Nota:

Es posible que haya observado que la ecuación mediante variables de tipo double puede completarse sin provocar un error. Un cálculo de división por cero mediante variables de tipo double devuelve un resultado igual a infinito, -infinito o "no un número". Esto no significa que deba usar siempre variables de tipo double en lugar de tipos int o decimal. El enfoque correcto consiste en usar variables del tipo adecuado e implementar el control de excepciones para detectar los errores que puedan producirse.
En la barra de herramientas Depurar, seleccione Continuar.
Dedique un minuto a examinar la salida del mensaje de la aplicación.
```
∞
Unhandled exception. System.DivideByZeroException: Attempted to divide by zero.
   at Program.<Main>$(String[] args) in C:\Users\msuser\Desktop\Exceptions101\Program.cs:line 7
```
Observe que la excepción no controlada ha provocado que la aplicación se apague después de que se haya completado la primera Console.WriteLine() instrucción.

Nota:

De forma predeterminada, Visual Studio Code usa un texto de color diferente para mostrar los mensajes generados por el depurador. Esto ayuda al desarrollador a diferenciar entre los mensajes de salida de la aplicación y del depurador. Si desea una vista más limpia de la salida de la aplicación, puede configurar el archivo launch.json para usar una consola diferente. Por ejemplo, establezca console en integratedTerminal para usar el panel TERMINAL para la salida de la aplicación. Los mensajes del depurador siempre se muestran en el panel CONSOLA DE DEPURACIÓN.

Incluya los dos cálculos dentro del bloque de código de una try instrucción como se indica a continuación:

double float1 = 3000.0;
double float2 = 0.0;
int number1 = 3000;
int number2 = 0;

try
{
    Console.WriteLine(float1 / float2);
    Console.WriteLine(number1 / number2);
}

Console.WriteLine("Exit program");

Observe la línea ondulada roja bajo el corchete de cierre del bloque try.

La sintaxis de C# requiere una cláusula catch o finally cuando se usa una declaración try.

Cree un catch bloque de código debajo del bloque de try código como se indica a continuación:

try
{
    Console.WriteLine(float1 / float2);
    Console.WriteLine(number1 / number2);
}
catch
{
    Console.WriteLine("An exception has been caught");
}

En el menú Archivo de Visual Studio Code, seleccione Guardar.
En el menú Ejecutar, seleccione Iniciar depuración.
Dedique un minuto a examinar la salida generada por la aplicación.
```
∞
An exception has been caught
Exit program
```
Tenga en cuenta que, aunque la excepción todavía se produce, la aplicación ahora puede terminar de ejecutar las líneas de código restantes antes de cerrarse.

El control de excepciones permite controlar la ejecución del código cuando se producen excepciones. El control de excepciones ayuda a garantizar que el código es estable y genera los resultados esperados.

Detectar excepciones iniciadas en métodos llamados

En muchos casos, se detecta una excepción en un nivel de la pila de llamadas que está por debajo del nivel en el que se produjo.

Cuando se produce una excepción y el método actual no detecta la excepción, Common Language Runtime desenredará la pila, buscando un método que contenga una catch cláusula que pueda controlar la excepción. La primera catch cláusula encontrada que puede controlar la excepción se ejecutará. Si no se encuentra ninguna cláusula adecuada catch en ninguna parte de la pila de llamadas, Common Language Runtime finalizará el proceso y mostrará un mensaje de error al usuario.

Reemplace el código del archivo Program.cs por el código siguiente:

try
{
    Process1();
}
catch
{
    Console.WriteLine("An exception has occurred");
}

Console.WriteLine("Exit program");

static void Process1()
{
    WriteMessage();
}

static void WriteMessage()
{
    double float1 = 3000.0;
    double float2 = 0.0;
    int number1 = 3000;
    int number2 = 0;

    Console.WriteLine(float1 / float2);
    Console.WriteLine(number1 / number2);
}

Dedique un minuto a revisar el código actualizado.
- Las instrucciones de nivel superior incluyen el bloque de código try que llama al método Process1().
- El método Process1() llama al método WriteMessage().
- El WriteMessage() método contiene el código donde se producirá la DivideByZeroException excepción.
Observe que la excepción se generará en un método que esté dos niveles por encima en la pila de llamadas de los bloques de código try y catch.

Las instrucciones de nivel superior se representan como un método denominado Main en la pila de llamadas.
En el menú Archivo de Visual Studio Code, seleccione Guardar.
En el menú Ejecutar, seleccione Iniciar depuración.
Dedique un minuto a examinar la salida generada por la aplicación.
```
∞
An exception has occurred
Exit program
```
Tenga en cuenta que, aunque la excepción se inicia dos niveles en la pila de llamadas, todavía se controla correctamente.

Resumen

Estos son algunos de los aspectos más importantes que debe recordar de esta unidad:

Implemente un try-catch patrón para try las líneas de código especificadas dentro de la aplicación y catch las excepciones que se producen dentro del ámbito del try bloque de código.
Use una cláusula catch para detectar una excepción iniciada en el mismo nivel de la pila de llamadas.
Use una catch cláusula para detectar una excepción producida en un nivel superior de la pila de llamadas.

Comentarios

¿Le ha resultado útil esta página?