Esercizio - Implementare la gestione delle eccezioni try-catch

9 minuti

Il try-catch criterio è costituito da un try blocco seguito da una o più catch clausole. Ogni catch clausola specifica il gestore per un tipo di eccezione diverso.

Quando viene generata un'eccezione, Common Language Runtime (CLR) cerca una catch clausola in grado di gestire l'eccezione. Se il metodo attualmente in esecuzione non contiene una catch clausola in grado di gestire il tipo di eccezione generata, CLR cerca il metodo che ha chiamato il metodo corrente. La ricerca continua attraverso lo stack di chiamate fino a quando non viene trovata una clausola appropriata catch . Se non viene trovata alcuna catch clausola per gestire l'eccezione, CLR visualizza un messaggio di eccezione non gestito all'utente e arresta l'esecuzione del programma.

In questo esercizio si implementerà un modello di base try-catch .

Creare un nuovo progetto di codice

Il primo passaggio consiste nel creare un progetto di codice usato durante questo modulo.

Aprire una nuova istanza di Visual Studio Code.
Nel menu File selezionare Apri cartella.
Nella finestra di dialogo Apri cartella passare alla cartella Desktop di Windows.
Nella finestra di dialogo Apri cartella selezionare Nuova cartella.
Assegnare alla nuova cartella il nome Exceptions101 e quindi selezionare Seleziona cartella.
Dal menu Terminale scegliere Nuovo terminale.

Userai un comando CLI di .NET per creare una nuova applicazione console.
Al prompt dei comandi del pannello TERMINAL immettere i comandi seguenti:
```
dotnet new console
```
Chiudere il pannello TERMINALE.

Implementare un semplice try-catch

Usare la visualizzazione EXPLORER di Visual Studio Code per aprire il file Program.cs.
Nel menu Visualizza, seleziona Palette comandi.
Al prompt dei comandi immettere .net: g e quindi selezionare .NET: Generare asset per la compilazione e il debug.

Sostituire il contenuto del file Program.cs con il codice seguente:

double float1 = 3000.0;
double float2 = 0.0;
int number1 = 3000;
int number2 = 0;

Console.WriteLine(float1 / float2);
Console.WriteLine(number1 / number2);
Console.WriteLine("Exit program");

Soffermarsi qualche istante a esaminare il codice.

Si noti che l'applicazione usa due tipi di variabili numeriche e doubleint. Il codice esegue un calcolo di divisione usando entrambi i tipi numerici.

Gli sviluppatori usano una double variabile di tipo per i calcoli quando i valori frazionari precisi sono importanti.
Nel menu Esegui selezionare Avvia debug.

Si noti che si verifica un'eccezione DivideByZeroException durante la divisione dei valori interi.

Annotazioni

Si potrebbe notare che l'equazione che usa variabili di tipo double è in grado di completare senza causare un errore. Un calcolo di divisione per zero tramite variabili di tipo double restituisce un risultato uguale a infinito, -infinito o "non un numero". Questo non significa che si debba sempre usare variabili di tipo double anziché tipi int o decimal. L'approccio corretto consiste nell'usare le variabili del tipo appropriato e implementare la gestione delle eccezioni per rilevare eventuali errori che potrebbero verificarsi.
Sulla barra degli strumenti Debug selezionare Continua.
Soffermarsi qualche istante a esaminare l'output dei messaggi per l'applicazione.
```
∞
Unhandled exception. System.DivideByZeroException: Attempted to divide by zero.
   at Program.<Main>$(String[] args) in C:\Users\msuser\Desktop\Exceptions101\Program.cs:line 7
```
Si noti che l'eccezione non gestita ha causato l'arresto dell'applicazione dopo il completamento della prima Console.WriteLine() istruzione.

Annotazioni

Per impostazione predefinita, Visual Studio Code usa un testo a colori diverso per visualizzare i messaggi generati dal debugger. Ciò consente allo sviluppatore di distinguere tra i messaggi di output dell'applicazione e i messaggi del debugger. Se si vuole una visualizzazione più chiara dell'output dell'applicazione, è possibile configurare il file launch.json per l'uso di una console diversa. Ad esempio, impostare console su integratedTerminal per usare il pannello TERMINALE per l'output dell'applicazione. I messaggi del debugger vengono sempre visualizzati nel pannello DEBUG CONSOLE.

Racchiudere i due calcoli all'interno del blocco di codice di un'istruzione try come indicato di seguito:

double float1 = 3000.0;
double float2 = 0.0;
int number1 = 3000;
int number2 = 0;

try
{
    Console.WriteLine(float1 / float2);
    Console.WriteLine(number1 / number2);
}

Console.WriteLine("Exit program");

Si noti la linea ondulata rossa sotto la parentesi chiusa del blocco try.

La sintassi C# richiede una catch clausola o finally quando si usa un'istruzione try .

Creare un blocco di catch codice sotto il blocco di try codice come indicato di seguito:

try
{
    Console.WriteLine(float1 / float2);
    Console.WriteLine(number1 / number2);
}
catch
{
    Console.WriteLine("An exception has been caught");
}

Nel menu File di Visual Studio Code, selezionare Salva.
Nel menu Esegui selezionare Avvia debug.
Prenditi un momento per esaminare l'output prodotto dalla tua applicazione.
```
∞
An exception has been caught
Exit program
```
Si noti che anche se l'eccezione si verifica ancora, l'applicazione è ora in grado di completare l'esecuzione delle righe di codice rimanenti prima della chiusura.

La gestione delle eccezioni consente di controllare l'esecuzione del codice quando si verificano eccezioni. La gestione delle eccezioni consente di garantire che il codice sia stabile e produa i risultati previsti.

Intercettare le eccezioni generate nei metodi chiamati

In molti casi, viene rilevata un'eccezione a un livello dello stack di chiamate inferiore al livello in cui è stata generata.

Quando viene generata un'eccezione e il metodo corrente non intercetta l'eccezione, Common Language Runtime rimuoverà lo stack, cercando un metodo che contiene una catch clausola in grado di gestire l'eccezione. La prima catch clausola trovata in grado di gestire l'eccezione verrà eseguita. Se non viene trovata alcuna clausola appropriata catch nello stack di chiamate, Common Language Runtime terminerà il processo e visualizzerà un messaggio di errore all'utente.

Sostituire il codice nel file Program.cs con il codice seguente:

try
{
    Process1();
}
catch
{
    Console.WriteLine("An exception has occurred");
}

Console.WriteLine("Exit program");

static void Process1()
{
    WriteMessage();
}

static void WriteMessage()
{
    double float1 = 3000.0;
    double float2 = 0.0;
    int number1 = 3000;
    int number2 = 0;

    Console.WriteLine(float1 / float2);
    Console.WriteLine(number1 / number2);
}

Prenditi un momento per rivedere il codice aggiornato.
- Le istruzioni di primo livello includono il blocco di try codice che chiama il Process1() metodo .
- Il Process1() metodo chiama il WriteMessage() metodo .
- Il WriteMessage() metodo contiene il codice in cui verrà generata l'eccezione DivideByZeroException .
Si noti che l'eccezione verrà generata in un metodo con due livelli di stack di chiamate sopra i blocchi di try codice e catch .

Le istruzioni di primo livello sono rappresentate come metodo denominato Main nello stack di chiamate.
Nel menu File di Visual Studio Code, selezionare Salva.
Nel menu Esegui selezionare Avvia debug.
Prenditi un momento per esaminare l'output prodotto dalla tua applicazione.
```
∞
An exception has occurred
Exit program
```
Si noti che, anche se l'eccezione viene generata due livelli più in alto nello stack di chiamate, viene comunque gestita correttamente.

Riepilogo

Ecco i concetti più importanti di questa unità da ricordare:

Implementare un criterio try-catch per righe di codice try specificate all'interno dell'applicazione ed eccezioni catch che si verificano all'interno dell'ambito del blocco di codice try.
Usare una catch clausola per intercettare un'eccezione generata allo stesso livello dello stack di chiamate.
Usare una clausola catch per intercettare un'eccezione generata a un livello superiore dello stack di chiamate.

Commenti e suggerimenti

Questa pagina è stata utile?