Las excepciones en C# ofrecen una forma estructurada, uniforme y segura en cuanto a tipos de gestionar las condiciones de error que se producen durante la ejecución. Gestionar correctamente las excepciones y los errores es importante si quieres evitar que la aplicación se bloquee.
En C#, todas las excepciones tienen la clase System.Exception como tipo base. Contiene propiedades importantes como Message, que incluye una descripción legible por humanos del motivo por el que se ha lanzado la excepción.
Para indicar que debe producirse un error en una parte concreta del código, hay que crear un nuevo objeto de excepción y lanzarlo con la palabra clave throw:
using System;
static int Square(int number)
{
if (number >= 46341)
{
throw new ArgumentException($"Argument {number} cannot be higher than 46340 as its' square doesn't fit into int type.");
}
return number * number;
}
Cuando se lanza una excepción, el entorno de ejecución tiene la tarea de encontrar un fragmento de código que se encargue de gestionarla. Si no encuentra ningún controlador adecuado, el entorno de ejecución muestra el mensaje de la excepción no controlada y, además, detiene la ejecución del programa.
Para crear un controlador para una excepción, C# usa la instrucción try-catch, que consta de un bloque try y una o varias cláusulas catch. El bloque try debe contener y proteger el código que puede provocar que se lance la excepción. Las cláusulas catch deben contener el código que gestiona el comportamiento del programa una vez producido el error. Es importante tener en cuenta que el orden de las excepciones importa después del bloque try, ya que, cuando se enumeran varias excepciones, se ejecuta la primera cláusula catch que coincida.
try
{
if (number == 42)
{
throw new ArgumentException("The number cannot be equal to 42.", "number");
}
if (number < 0)
{
throw new ArgumentOutOfRangeException("number", "The number cannot be negative.");
}
// Process number ...
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine($"Number is out of range: {e.Message}.");
}
catch (ArgumentException)
{
Console.WriteLine("Invalid number.");
}
En este ejercicio vas a implementar la gestión de errores para una calculadora sencilla de números enteros. Para simplificar, se proporcionan los métodos para calcular la suma, la multiplicación y la división.
El objetivo es tener una calculadora funcional que devuelva un string con el siguiente patrón: 16 + 51 = 67, cuando se le proporcionan los argumentos 16, 51 y +.
SimpleCalculator.Calculate(16, 51, "+"); // => returns "16 + 51 = 67"
SimpleCalculator.Calculate(32, 6, "*"); // => returns "32 * 6 = 192"
SimpleCalculator.Calculate(512, 4, "/"); // => returns "512 / 4 = 128"
El método principal que hay que implementar en esta tarea será el método (static) SimpleCalculator.Calculate(). Recibe tres argumentos. Los dos primeros son números enteros sobre los que se va a realizar una operación. El tercero es de tipo string y, para este ejercicio, es necesario implementar las siguientes operaciones:
+
*
/
Cualquier otro símbolo de operación debe lanzar la excepción ArgumentOutOfRangeException. Si el argumento de operación es un string vacío, el método debe lanzar la excepción ArgumentException. Cuando se proporciona null como argumento de operación, el método debe lanzar la excepción ArgumentNullException.
SimpleCalculator.Calculate(100, 10, "-"); // => throws ArgumentOutOfRangeException
SimpleCalculator.Calculate(8, 2, ""); // => throws ArgumentException
SimpleCalculator.Calculate(58, 6, null); // => throws ArgumentNullException
Al intentar dividir entre 0, la calculadora debe devolver un string con el contenido Division by zero is not allowed.. El método SimpleCalculator.Calculate() no debe gestionar ninguna otra excepción.
SimpleCalculator.Calculate(512, 0, "/"); // => returns "Division by zero is not allowed."
Regístrate en Exercism para aprender y dominar C# con 62 conceptos178 ejercicios y mentoría humana real, todo gratis.