Tracks
/
C#
C#
/
Ejercicios
/
El enigma de la calculadora
El enigma de la calculadora

El enigma de la calculadora

Ejercicio de aprendizaje

Introducción

Excepciones

Las excepciones en C# ofrecen una forma estructurada, uniforme y con seguridad de tipos de manejar las condiciones de error que ocurren durante la ejecución. Manejar bien las excepciones y los errores es importante cuando se intenta evitar que la aplicación se bloquee.

En C#, todas las excepciones tienen la clase System.Exception como su tipo base. Esta contiene propiedades importantes, como Message, que contiene una descripción legible de la razón por la que se lanza la excepción.

Para indicar que debe haber un error en cierta parte del código, hay que crear un nuevo objeto de excepción y luego lanzarlo, usando 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 manejar esa excepción. Si no se encuentra un controlador adecuado, el entorno de ejecución muestra el mensaje de excepción no controlada, además de detener la ejecución del programa.

Para crear un controlador para una excepción, C# usa la sentencia try-catch, que consta de un bloque try y una o más 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 maneja el comportamiento del programa después de que haya ocurrido 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.");
}

Instrucciones

En este ejercicio vas a implementar el manejo de errores para una calculadora de números enteros sencilla. Para simplificar las cosas, 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 pasan 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"

1. Implementa las operaciones de la calculadora

El método principal que implementarás 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:

  • la suma usando el string +
  • la multiplicación usando el string *
  • la división usando el string /

2. Maneja las operaciones ilegales

Cualquier otro símbolo de operación debería lanzar la excepción ArgumentOutOfRangeException. Si el argumento de operación es un string vacío, entonces el método debería lanzar la excepción ArgumentException. Cuando se proporciona null como argumento de operación, entonces el método debería lanzar la excepción ArgumentNullException.

SimpleCalculator.Calculate(100, 10, "-"); // => throws ArgumentOutOfRangeException

SimpleCalculator.Calculate(8, 2, ""); // => throws ArgumentException

SimpleCalculator.Calculate(58, 6, null); // => throws ArgumentNullException

3. Maneja los errores al dividir entre cero

Cuando se intente dividir entre 0, la calculadora debería devolver un string con el contenido Division by zero is not allowed.. Ninguna otra excepción debería ser manejada por el método SimpleCalculator.Calculate().

SimpleCalculator.Calculate(512, 0, "/"); // => returns "Division by zero is not allowed."
Editar en GitHub El enlace se abre en una ventana o una pestaña nuevas
C# Exercism

¿Todo listo para empezar El enigma de la calculadora?

Regístrate en Exercism para aprender y dominar C# con 62 conceptos178 ejercicios y mentoría humana real, todo gratis.