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.");
}
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"
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:
+
*
/
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
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."
Iscriviti a Exercism per imparare e padroneggiare C# con 62 concetti178 esercizi e il mentoring di persone reali, tutto gratis.