c exception handling tutorial with code examples
La gestione delle eccezioni è un metodo per gestire gli errori che possono verificarsi durante l'esecuzione di un programma. Questo tutorial spiega la gestione delle eccezioni in C # con esempi di codice:
b-albero vs b + albero
La gestione delle eccezioni viene utilizzata per assicurarsi che il flusso del programma continui anche se si verifica un errore di runtime. Le eccezioni sono gli oggetti che vengono lanciati durante l'incontro con un errore di runtime.
Se le eccezioni non vengono gestite, C # produrrà un messaggio di eccezione e terminerà il programma, è qui che entra in gioco la gestione delle eccezioni.
=> Leggi la guida per principianti di C # qui
Cosa imparerai:
- Cosa sono le eccezioni?
- Parole chiave per la gestione delle eccezioni
- Classi di eccezione presenti in C #
- Gestione delle eccezioni in C #
- Conclusione
- Lettura consigliata
Cosa sono le eccezioni?
Le eccezioni sono errori senza precedenti che possono verificarsi all'interno del programma durante il runtime. La maggior parte delle volte i programmatori possono facilmente rilevare alcuni errori come la convalida o il controllo dei valori nulli o durante la verifica di alcuni valori.
Ma ci sono momenti in cui non possiamo anticipare cosa o quando apparirà un errore. Per esempio, diciamo che sto cercando un file in una posizione. Il mio programma funzionerà perfettamente fino a quando il file è presente e se in qualche modo il file è stato eliminato, il mio programma genererà un errore.
Le eccezioni non si verificano regolarmente ma possono comunque verificarsi e vorrai sempre gestirle con attenzione. Per gestirli utilizziamo la gestione delle eccezioni.
Ogni volta che si verifica un errore diciamo che viene lanciato, 'lanciato' è un oggetto da System.Exception classe in C #. Il System.Exception class offre diversi metodi e proprietà che forniscono dettagli sull'errore appena riscontrato dal programma.
Come la proprietà di traccia dello stack che fornisce lo stack per il quale si è verificato il problema o la proprietà Message che fornisce una descrizione dell'eccezione.
Parole chiave per la gestione delle eccezioni
Le eccezioni offrono un processo per controllare una certa parte del programma in modo che, anche se in quella parte è presente un'eccezione, il controllo del programma viene trasferito a un'altra parte del programma. In C # la gestione delle eccezioni è fondamentalmente costruita attorno a quattro parole chiave: lanciare, provare, prendere e infine .
come chiedere la promozione nella valutazione delle prestazioni
gettare
Come abbiamo già discusso, throw è un oggetto da System.Exception classe in C #. Consente al programma di lanciare un errore ogni volta che ne incontra uno.
provare
Try block racchiude il blocco del codice che potrebbe causare la generazione di un'eccezione da parte del programma. È seguito da uno o più blocchi di cattura.
catturare
Quando try block incontra un'eccezione, fornisce il controllo al blocco catch per catturare l'eccezione. Il blocco catch può anche contenere un insieme di codici che il programma deve eseguire in caso di un'eccezione oppure può semplicemente catturare l'eccezione e non fare nulla a seconda dello scenario e del requisito.
infine
Il blocco finale viene utilizzato per eseguire uno snippet di codice o un'istruzione particolare indipendentemente dal verificarsi di un'eccezione. Infine il blocco viene sempre eseguito, e può essere eseguito subito dopo il blocco di prova se il programma non trova alcuna eccezione o può essere eseguito dopo il blocco catch una volta che il programma rileva un'eccezione.
Classi di eccezione presenti in C #
Tutte le eccezioni in C # derivano direttamente o indirettamente da System.Exception classe.
Diamo una breve occhiata ad alcune delle eccezioni più comuni:
- System.IO.IOException: Gestisce tutti gli errori relativi a input e output.
- System.DividedByZeroException: Gestisce l'errore generato quando un numero viene diviso per zero.
- System.NullReferenceException : Gestisce qualsiasi errore che può verificarsi quando si fa riferimento a un oggetto null.
- System.IndexOutOfRangeException: Gestisce l'errore generato quando un programma tenta di accedere a un indice che non rientra nell'intervallo per l'array.
- System.OutOfMemoryException: Gestisce l'errore generato a causa della presenza di memoria insufficiente.
Gestione delle eccezioni in C #
C # ha una soluzione molto ben definita per la gestione di qualsiasi tipo di eccezione che può verificarsi utilizzando il blocco try and catch. Usando questo blocco, l'istruzione principale del programma può essere separata dalle altre istruzioni.
Esempio:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.IO; namespace ConsoleApp1 { class Program { static void Main(string() args) { try { File.OpenRead('InvalidFile'); } catch (FileNotFoundException ex) { Console.WriteLine(ex.ToString()); } Console.ReadLine(); } } }
Nell'esempio sopra, abbiamo racchiuso il nostro codice per l'apertura di un file sotto il blocco try. Poiché non abbiamo fornito alcun percorso di file valido, il codice dovrebbe generare un errore. Ora, abbiamo rilevato l'errore nel nostro blocco catch. Se il file non esiste nel percorso file specificato, il codice genererà un'eccezione FileNotFoundException.
Questa eccezione verrà rilevata dal blocco catch in cui abbiamo già definito l'eccezione attesa. Ora, immaginiamo se il nostro codice genera qualche altra eccezione, diversa da quella che abbiamo già definito, il nostro blocco non sarà in grado di catturarla. Per catturare qualsiasi eccezione generica, aggiungeremo un altro blocco di cattura.
Diamo un'occhiata al nostro codice aggiornato:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.IO; namespace ConsoleApp1 { class Program { static void Main(string() args) { try { File.OpenRead('InvalidFile'); } catch (FileNotFoundException ex) { Console.WriteLine(ex.ToString()); } catch (Exception e) { Console.WriteLine(e.ToString()); } Console.ReadLine(); } } }
Questo blocco catch generico sarà in grado di catturare tutte le eccezioni che possono essere lanciate all'interno del blocco try. Ora, aggiungiamo anche un blocco finalmente per completare l'operazione. Per semplificare, stampiamo un messaggio utilizzando il blocco finalmente.
domande e risposte dell'intervista al tester della qualità
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.IO; namespace ConsoleApp1 { class Program { static void Main(string() args) { try { File.OpenRead('InvalidFile'); } catch (FileNotFoundException ex) { Console.WriteLine(ex.ToString()); } catch (Exception e) { Console.WriteLine(e.ToString()); } finally { Console.WriteLine('Finally block executed'); } Console.ReadLine(); } } }
Qui abbiamo appena aggiunto il blocco finalmente con un semplice messaggio. Puoi anche aggiungere alcune istruzioni personalizzate nel blocco. Ma la struttura generale del programma rimarrà simile a quella visualizzata qui.
Il blocco Finalmente verrà sempre eseguito indipendentemente dal fatto che ci sia o meno un'eccezione. Il programma partirà dal blocco try e si sposterà poi direttamente al blocco finalmente se non ci sono errori / eccezioni. Se incontra un'eccezione, si muoverà per catturare prima e quindi eseguirà il blocco finale.
C'è una condizione in cui il blocco finalmente non verrà eseguito?
Come suggerisce il nome, il blocco finale viene eseguito alla fine ed è il blocco finale del codice che verrà eseguito. Infine il blocco verrà sempre eseguito quando l'applicazione è in esecuzione. L'unico momento in cui il blocco finale non verrà eseguito è quando l'applicazione si arresta in modo anomalo o viene intenzionalmente interrotta utilizzando il comando di processo.
Conclusione
Se le eccezioni non vengono gestite correttamente, causeranno errori all'interno del programma. Se non hai utilizzato i blocchi try / catch da nessuna parte all'interno del codice, il programma si interromperà con un messaggio che mostra l'eccezione. Per un utente generico, sarà molto difficile risalire all'errore nel codice sorgente e risolverlo.
Pertanto, è sempre buona norma fornire la gestione delle eccezioni nel programma.
Codice di esempio
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.IO; namespace ConsoleApp1 { class Program { static void Main(string() args) { try { File.OpenRead('InvalidFile'); } catch (FileNotFoundException ex) { Console.WriteLine(ex.ToString()); } catch (Exception e) { Console.WriteLine(e.ToString()); } finally { Console.WriteLine('Finally block executed'); } Console.ReadLine(); } } }
=> Guarda la nostra serie completa di formazione C # qui
Lettura consigliata
- Esercitazione su funzioni / metodi C # con esempi di codice
- Tutorial Python DateTime con esempi
- Tutorial SVN: gestione del codice sorgente mediante Subversion
- Esercitazione sulle stringhe in C #: metodi sulle stringhe con esempi di codice
- Gestione delle eccezioni in C ++
- Tutorial SVN tartaruga: revisioni nel repository di codice
- Tutorial AWS CodeBuild: estrazione del codice da Maven Build
- Come gestire le eccezioni negli script Groovy SoapUI - Tutorial SoapUI # 11