Track
/
C#
C#
/
Esercizi
/
L'enigma della calcolatrice
L'enigma della calcolatrice

L'enigma della calcolatrice

Esercizio di apprendimento

Introduzione

Le eccezioni

In C#, le eccezioni forniscono un modo strutturato, uniforme e type-safe di gestire le condizioni di errore che si verificano durante l'esecuzione. Una gestione corretta delle eccezioni e degli errori è importante per evitare che l'applicazione vada in crash.

In C#, tutte le eccezioni hanno la classe System.Exception come tipo di base. Questa contiene proprietà importanti, come Message, che racchiude una descrizione leggibile del motivo per cui l'eccezione è stata lanciata.

Per segnalare che si è verificato un errore in una certa parte del codice, è necessario creare un nuovo oggetto eccezione e poi lanciarlo, usando la parola chiave 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;
}

Quando viene lanciata un'eccezione, il runtime ha il compito di trovare un pezzo di codice responsabile della sua gestione. Se non viene trovato un gestore adeguato, il runtime mostra il messaggio di eccezione non gestita e interrompe l'esecuzione del programma.

Per creare un gestore per un'eccezione, C# usa l'istruzione try-catch, composta da un blocco try e da una o più clausole catch. Il blocco try deve contenere e proteggere il codice che potrebbe causare il lancio dell'eccezione. Le clausole catch devono contenere il codice che gestisce il comportamento del programma dopo che si è verificato l'errore. È importante notare che l'ordine delle eccezioni è rilevante dopo il blocco try: quando sono elencate più eccezioni, viene eseguita la prima clausola catch che corrisponde.

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

Istruzioni

In questo esercizio costruirai la gestione degli errori per una semplice calcolatrice di numeri interi. Per semplificare, sono forniti i metodi per calcolare l'addizione, la moltiplicazione e la divisione.

L'obiettivo è avere una calcolatrice funzionante che restituisce una stringa con questo schema: 16 + 51 = 67, quando riceve gli argomenti 16, 51 e +.

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 le operazioni della calcolatrice

Il metodo principale da implementare in questo compito sarà il metodo (static) SimpleCalculator.Calculate(). Richiede tre argomenti. I primi due argomenti sono numeri interi sui quali verrà eseguita un'operazione. Il terzo argomento è di tipo stringa e per questo esercizio è necessario implementare le seguenti operazioni:

  • addizione usando la stringa +
  • moltiplicazione usando la stringa *
  • divisione usando la stringa /

2. Gestisci le operazioni non valide

Qualsiasi altro simbolo di operazione deve lanciare l'eccezione ArgumentOutOfRangeException. Se l'argomento dell'operazione è una stringa vuota, il metodo deve lanciare l'eccezione ArgumentException. Quando viene fornito null come argomento dell'operazione, il metodo deve lanciare l'eccezione ArgumentNullException.

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

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

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

3. Gestisci gli errori quando si divide per zero

Quando si tenta di dividere per 0, la calcolatrice deve restituire una stringa con il contenuto Division by zero is not allowed.. Qualsiasi altra eccezione non deve essere gestita dal metodo SimpleCalculator.Calculate().

SimpleCalculator.Calculate(512, 0, "/"); // => returns "Division by zero is not allowed."
Modifica tramite GitHub Il link si apre in una nuova finestra o scheda
C# Exercism

Vuoi iniziare L'enigma della calcolatrice?

Iscriviti a Exercism per imparare e padroneggiare C# con 62 concetti178 esercizi e il mentoring di persone reali, tutto gratis.