Parcours
/
C#
C#
/
Exercices
/
Le casse-tête de la calculatrice
Le casse-tête de la calculatrice

Le casse-tête de la calculatrice

Exercice d'apprentissage

Introduction

Exceptions

Les exceptions en C# offrent une façon structurée, uniforme et sûre au niveau des types de gérer les conditions d'erreur qui surviennent pendant l'exécution. Une gestion correcte des exceptions et des erreurs est importante pour éviter que l'application ne plante.

En C#, toutes les exceptions ont la classe System.Exception pour type de base. Elle définit des propriétés importantes telles que Message, qui contient une description lisible par un humain de la raison pour laquelle l'exception est levée.

Pour signaler qu'il doit y avoir une erreur à un certain endroit du code, il faut créer un nouvel objet exception, puis le lever, à l'aide du mot-clé 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;
}

Quand une exception est levée, le runtime a pour tâche de trouver un bout de code chargé de gérer cette exception. Si aucun gestionnaire approprié n'est trouvé, le runtime affiche le message de l'exception non gérée et arrête l'exécution du programme.

Pour créer un gestionnaire d'exception, C# utilise l'instruction try-catch, qui se compose d'un bloc try et d'une ou plusieurs clauses catch. Le bloc try doit contenir et protéger du code susceptible de lever l'exception. Les clauses catch doivent contenir le code qui gère le comportement du programme après que l'erreur s'est produite. Il est important de noter que l'ordre des exceptions compte après le bloc try : comme plusieurs exceptions peuvent être listées, c'est la première clause catch correspondante qui s'exécute.

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.");
}

Instructions

Dans cet exercice, on va mettre en place la gestion des erreurs d'une calculatrice simple pour nombres entiers. Pour simplifier, des méthodes permettant de calculer une addition, une multiplication et une division sont fournies.

L'objectif est d'obtenir une calculatrice fonctionnelle qui renvoie une string selon le modèle suivant : 16 + 51 = 67, lorsqu'on lui passe les arguments 16, 51 et +.

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. Implémente les opérations de la calculatrice

La principale méthode à implémenter dans cette tâche sera la méthode (statique) SimpleCalculator.Calculate(). Elle prend trois arguments. Les deux premiers arguments sont des nombres entiers sur lesquels une opération va être effectuée. Le troisième argument est de type string et, pour cet exercice, il est nécessaire d'implémenter les opérations suivantes :

  • l'addition avec la string +
  • la multiplication avec la string *
  • la division avec la string /

2. Gère les opérations illégales

Tout autre symbole d'opération doit lever l'exception ArgumentOutOfRangeException. Si l'argument d'opération est une string vide, la méthode doit lever l'exception ArgumentException. Lorsque null est passé comme argument d'opération, la méthode doit lever l'exception ArgumentNullException.

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

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

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

3. Gère les erreurs de division par zéro

Lorsqu'on tente de diviser par 0, la calculatrice doit renvoyer une string contenant Division by zero is not allowed.. Toute autre exception ne doit pas être gérée par la méthode SimpleCalculator.Calculate().

SimpleCalculator.Calculate(512, 0, "/"); // => returns "Division by zero is not allowed."
Modifie via GitHub Le lien s'ouvre dans une nouvelle fenêtre ou un nouvel onglet
C# Exercism

Prêt à commencer Le casse-tête de la calculatrice ?

Inscris-toi sur Exercism pour apprendre et maîtriser C# avec 62 concepts178 exercices, et un vrai mentorat humain, le tout gratuitement.