Cos'è un'eccezione?
Un'eccezione si riferisce a un problema che si verifica durante l'esecuzione del programma. È causato da una circostanza inaspettata. Un buon esempio è quando si esegue un'operazione di divisione e quindi si divide per zero (0). Verrà sollevata un'eccezione.
In questo tutorial di Visual Basic imparerai:
- Cos'è un'eccezione?
- Che cos'è la gestione delle eccezioni?
- Sintassi di Try / Catch
- Esempio per gestire le eccezioni
- Eccezioni definite dall'utente
- Lanciare oggetti
Che cos'è la gestione delle eccezioni?
Tranne eccezioni, è possibile trasferire il controllo di un programma da una parte all'altra. In VB.NET, le eccezioni vengono gestite utilizzando le seguenti 4 parole chiave:
| Parola chiave | Dettaglio |
| Provare | Il lavoro del blocco Try è identificare il blocco di codice per il quale verrà attivata una specifica eccezione. Dovrebbe essere seguito da uno o più blocchi di cattura. |
| Catturare | La cattura dell'eccezione viene eseguita in questo blocco. È un gestore di eccezioni in cui viene gestita l'eccezione. |
| Infine | Utilizzare il blocco Infine per eseguire una serie di istruzioni indipendentemente dal fatto che si sia verificata o meno un'eccezione. |
| Gettare | Viene generata un'eccezione dopo il verificarsi di un problema. Questo è il lavoro della parola chiave Lancio. |
Sintassi di Try / Catch
Le istruzioni Try / Catch adottano la sintassi indicata di seguito:
Try[ try_Statement(s) ][ Exit Try ][ Catch [ exception_name [ As type ] ] [ When expression ][ catch_Statement(s) ][ Exit Try ] ][ Catch… ][ Finally[ finally_Statement(s) ] ]End Try
Il blocco Try / Catch dovrebbe racchiudere il codice che potrebbe sollevare un'eccezione. Questo codice è noto come codice protetto. È possibile utilizzare più istruzioni catch quando è necessario rilevare vari tipi di eccezioni.
Esempio per gestire le eccezioni
Con le istruzioni Try / Catch, è possibile separare il codice del programma ordinario dal sistema di gestione degli errori. Dimostriamo come gestire un'eccezione utilizzando le parole chiave Try, Catch e Infine.
Passaggio 1) Crea una nuova applicazione console.
Passaggio 2) Usa questo codice:
Module Module1Sub divisionFunction(ByVal n1 As Integer, ByVal n2 As Integer)Dim answer As IntegerTryanswer = n1 \ n2Catch ex As DivideByZeroExceptionConsole.WriteLine("Exception: {0}", ex)FinallyConsole.WriteLine("Answer is: {0}", answer)End TryEnd SubSub Main()divisionFunction(4, 0)Console.ReadKey()End SubEnd Module
Passaggio 3) Fare clic sul pulsante Start dalla barra degli strumenti per eseguire il codice. Dovresti ottenere il seguente output:
Ecco uno screenshot del codice:
Spiegazione del codice:
- Creazione di un modulo denominato Module1.
- Creazione di una sottoprocedura denominata divisionFunction con due argomenti interi n1 e n2. ByVal è una parola chiave VB.NET che indica che i valori degli argomenti verranno passati per valore.
- Creazione di una variabile intera denominata risposta.
- Inizio del blocco Try / Catch. Dobbiamo racchiudere il codice che sospettiamo possa sollevare un'eccezione con questo blocco.
- Esecuzione di un'operazione di divisione tra i valori delle variabili n1 e n2. Il risultato dell'operazione di divisione viene assegnato alla variabile risposta. Questo codice può sollevare un'eccezione, ad esempio, quando dividiamo un numero per zero, quindi lo abbiamo circondato con i blocchi Try / Catch.
- Catturare l'eccezione denominata DivideByZeroException e assegnare il messaggio di eccezione generato all'ex.
- Stampa del testo sulla console per notificare all'utente il tipo / nome dell'eccezione sollevata.
- Il blocco Finalmente. Questo verrà eseguito indipendentemente dal fatto che un'eccezione venga rilevata o meno.
- Stampa del testo sulla console che mostra il risultato dell'operazione di divisione.
- Fine del blocco Try, ovvero fine del codice di gestione degli errori.
- Fine della sotto-procedura di divisione delle funzioni.
- Inizio della sottoprocedura principale.
- Chiamata / invocazione della sottoprocedura divisionFunction. I valori dei due argomenti interi vengono passati qui. Il valore di n1 = 4 e n2 = 0. Ciò significa che l'operazione di divisione sarà 4 \ 0, ovvero n1 \ n2.
- Mettere in pausa la finestra della console in attesa che l'utente intraprenda un'azione per chiuderla.
- Fine della sottoprocedura principale.
- Fine del modulo.
Eccezioni definite dall'utente
VB.NET ti consente di definire le tue eccezioni. È possibile ottenere classi di eccezioni definite dall'utente dalla classe ApplicationException. Dimostriamolo con un esempio:
Passaggio 1) Crea una nuova applicazione console.
Passaggio 2) Utilizza il codice seguente:
Module Module1Public Class HeightIsZeroException : Inherits ApplicationExceptionPublic Sub New(ByVal text As String)MyBase.New(text)End SubEnd ClassPublic Class HeightDim height As Integer = 0Sub showHeight()If (height = 0) ThenThrow (New HeightIsZeroException("Zero Height found"))ElseConsole.WriteLine("Height is: {0}", height)End IfEnd SubEnd ClassSub Main()Dim hght As Height = New Height()Tryhght.showHeight()Catch ex As HeightIsZeroExceptionConsole.WriteLine("HeightIsZeroException: {0}", ex.Message)End TryConsole.ReadKey()End SubEnd Module
Passaggio 3) Fare clic sul pulsante Start dalla barra in alto per eseguire il codice. Dovresti ottenere il seguente output:
Ecco uno screenshot del codice:
Spiegazione del codice:
- Creazione di un modulo denominato Module1.
- Creazione di una classe di eccezione denominata HeightIsZeroException. La classe eredita tutta la classe ApplicationException.
- Creazione di una sottoprocedura denominata New. Ci vorrà un argomento stringa chiamato text.
- Chiamando il costruttore della classe base e passando ad esso l'argomento precedente.
- Fine della nuova sottoprocedura.
- Fine della classe HeightIsZeroException.
- Creazione di una classe denominata Height. Il suo modificatore di accesso pubblico è Pubblico, il che significa che sarà accessibile pubblicamente.
- Creazione di una variabile intera denominata Altezza e inizializzazione del suo valore su 0.
- Creazione di una sottoprocedura denominata showHeight ().
- Verificare quando il valore della variabile Altezza è 0. Abbiamo utilizzato la condizione If ... Then.
- Per generare l'eccezione HeightIsZeroException se la condizione precedente è vera. Quando viene generata questa eccezione, verrà visualizzato il messaggio Altezza zero trovata.
- La parte Else da eseguire quando la condizione If non è vera.
- Messaggio da stampare sulla console che mostra l'altezza quando non è 0.
- Fine della condizione If.
- Fine della sottoprocedura showHeight ().
- Fine della classe Altezza.
- Inizio della sottoprocedura principale.
- Creazione di un oggetto denominato Height come istanza della classe Height.
- Inizio del blocco di gestione delle eccezioni.
- Richiamo della sottoprocedura showHeight () definita nella classe Height. Abbiamo utilizzato un oggetto di questa classe per accedere a questo metodo. Questa riga può risultare in un'eccezione. Pertanto, lo abbiamo circondato con un codice di gestione delle eccezioni.
- Catturare l'eccezione HeightIsZeroException come oggetto ex nel caso in cui si verifichi.
- Il messaggio da stampare sulla console quando viene rilevata l'eccezione HeightIsZeroException.
- Fine del blocco di gestione delle eccezioni.
- Metti in pausa la finestra della console in attesa che un utente esegua un'azione per chiuderla.
- Fine della sottoprocedura principale.
- Fine del modulo.
Lanciare oggetti
Nella gestione delle eccezioni, puoi scegliere di lanciare un oggetto. Tuttavia, l'oggetto deve essere derivato da System. Classe di eccezione, direttamente o indirettamente. Per esempio:
Passaggio 1) Crea una nuova applicazione console.
Passaggio 2) Utilizza il codice seguente:
Module Module1Sub Main()TryThrow New ApplicationException("Throwing a custom exception")Catch ex As ExceptionConsole.WriteLine(ex.Message)FinallyConsole.WriteLine("The Finally Block")End TryConsole.ReadKey()End SubEnd Module
Passaggio 3) Fare clic sul pulsante Start dalla barra in alto per eseguire il codice. Dovresti ottenere quanto segue:
Ecco uno screenshot del codice:
Spiegazione del codice:
- Creazione di un modulo denominato Module1.
- Inizio della sottoprocedura principale.
- Inizio del codice di gestione degli errori.
- Lanciare un oggetto eccezione. Questo codice può generare un'eccezione, quindi lo abbiamo circondato con un blocco Try / Catch.
- Catturare un'eccezione come oggetto ex se la riga genera un'eccezione.
- Stampa il messaggio di eccezione sulla console nel caso in cui si verifichi.
- Il blocco Infine da eseguire indipendentemente dal fatto che venga rilevata un'eccezione.
- Il messaggio da stampare sulla console quando viene eseguito il blocco Finalmente.
- Fine del codice di gestione delle eccezioni.
- Metti in pausa la console per un po 'in attesa che un utente esegua un'azione per chiuderla.
- Fine della sottoprocedura principale.
- Fine del modulo.
Sommario
- Un'eccezione si riferisce a un problema che si verifica durante l'esecuzione del programma causato da una circostanza imprevista.
- Se sospetti che un codice genererà un'eccezione, circondalo con un blocco Try / Catch.
- Il blocco Infine viene dopo il blocco Try / Catch e viene eseguito indipendentemente dal fatto che un'eccezione venga rilevata o meno.
- VB.NET ci permette di creare eccezioni personalizzate.