Istruzione Try...Catch...Finally (Visual Basic)

Articolo
08/11/2011

Consente di gestire alcuni o tutti i possibili errori che possono verificarsi in un determinato blocco di codice in esecuzione.

Try
    [ tryStatements ]
    [ Exit Try ]
[ Catch [ exception [ As type ] ] [ When expression ]
    [ catchStatements ]
    [ Exit Try ] ]
[ Catch ... ]
[ Finally
    [ finallyStatements ] ]
End Try

Parti

Argomento	Definizione
tryStatements	Facoltativo. Una o più istruzioni in cui può verificarsi un errore. Può trattarsi di un'istruzione composta.
Catch	Facoltativo. Sono ammessi più blocchi Catch. Se durante l'elaborazione del blocco Try si verifica un'eccezione, ogni istruzione Catch viene esaminata in ordine testuale per stabilire se gestisce l'eccezione. L'eccezione generata è rappresentata da exception.
exception	Facoltativo. Qualsiasi nome di variabile. Il valore iniziale di exception corrisponde al valore dell'errore generato. Viene utilizzata con Catch per specificare l'errore intercettato. Se omessa, l'istruzione Catch genera un'eccezione.
type	Facoltativo. Consente di specificare il tipo di classe filtrato. Se il valore di exception è del tipo specificato da type o di un tipo derivato da questo, l'identificatore viene associato all'oggetto eccezione.
When	Facoltativo. Un'istruzione Catch con una clausola When intercetta eccezioni solo quando expression restituisce True. Una clausola When viene applicata soltanto dopo il controllo del tipo di eccezione; expression può fare riferimento all'identificatore che indica l'eccezione.
expression	Facoltativo. Deve essere convertibile in modo implicito in un valore di tipo Boolean. Qualsiasi espressione in cui è descritto un filtro generico. Utilizzato in genere per filtrare in base al numero di errore. Viene utilizzato con la parola chiave When per specificare le circostanze in cui è stato intercettato l'errore.
catchStatements	Facoltativo. Una o più istruzioni per la gestione degli errori verificatisi nel blocco Try associato. Può trattarsi di un'istruzione composta.
Exit Try	Facoltativo. Parola chiave con cui viene interrotta la struttura Try...Catch...Finally. L'esecuzione riprende con il codice immediatamente successivo all'istruzione End Try. Verrà eseguita l'istruzione Finally. Non ammessa nei blocchi Finally.
Finally	Facoltativo. Blocco Finally che viene eseguito tutte le volte che l'esecuzione abbandona l'istruzione Try...Catch in un punto qualsiasi.
finallyStatements	Facoltativo. Una o più istruzioni eseguite dopo l'elaborazione di tutti gli altri errori.
End Try	Consente di terminare la struttura Try...Catch...Finally.

Note

Se si prevede il verificarsi di una determinata eccezione nel corso di una particolare sezione di codice, inserire il codice in un blocco Try e utilizzare un blocco Catch per mantenere il controllo e gestire l'eccezione nel caso in cui si verifichi.

Un'istruzione Try…Catch è costituita da un blocco Try seguito da una o più clausole Catch, mediante le quali vengono specificati i gestori per diverse eccezioni. Quando viene generata un'eccezione in un blocco Try, tramite Visual Basic viene cercata l'istruzione Catch mediante la quale viene gestita l'eccezione. Se non viene individuata un'istruzione Catch corrispondente, il metodo mediante il quale è stata eseguita la chiamata al metodo corrente e così via lungo lo stack di chiamate viene esaminato da Visual Basic. Se non viene trovato alcun blocco Catch, in Visual Basic viene visualizzato un messaggio di eccezione non gestita e l'esecuzione del programma viene arrestata.

È possibile utilizzare più istruzioni Catch in un'istruzione Try…Catch. In tal caso, l'ordine delle clausole Catch è importante poiché vengono esaminate nell'ordine specificato. Vengono intercettate prima le eccezioni più specifiche, quindi quelle meno specifiche.

Le seguenti condizioni dell'istruzione Catch sono quelle meno specifiche e consentono di rilevare tutte le eccezioni che derivano dalla classe Exception. Di norma, si consiglia di utilizzare una di queste variazioni come ultimo blocco Catch nella struttura Try...Catch...Finally, una volta generate tutte le eccezioni specifiche previste. Il flusso di controllo non può raggiungere mai un blocco Catch che segue una di queste variazioni.

Il valore di type è Exception, ad esempio: Catch ex As Exception
Nell'istruzione non sono presenti variabili exception, ad esempio: Catch

Quando un'istruzione Try…Catch…Finally è annidata in un altro blocco Try, in Visual Basic viene esaminata dapprima ciascuna istruzione Catch nella parte più interna del blocco Try. Se non viene trovata alcuna istruzione Catch corrispondente, si continua la ricerca nelle istruzioni Catch del blocco Try…Catch…Finally esterno.

Le variabili locali di un blocco Try non sono disponibili in un blocco Catch in quanto rappresentano blocchi separati. Se si desidera utilizzare una variabile in più blocchi, dichiarare la variabile al di fuori della struttura Try...Catch...Finally.

Suggerimento
L'istruzione Try…Catch…Finally è disponibile come frammento di codice IntelliSense. In Gestione frammenti di codice espandere Modelli di codice - If, For Each, Try Catch, Property e così via, quindi Gestione errori (Eccezioni). Per ulteriori informazioni, vedere Procedura: inserire frammenti di codice IntelliSense.

Blocco finally

Se si dispone di una o più istruzioni da eseguire prima di uscire dalla struttura Try, utilizzare un blocco Finally. Il controllo viene passato al blocco Finally appena prima dell'uscita dalla struttura Try…Catch. Il passaggio avviene anche se si verifica un'eccezione in qualsiasi posizione all'interno della struttura Try.

Un blocco Finally è utile per l'esecuzione di qualsiasi codice sia necessario eseguire persino in presenza di un'eccezione. Il controllo viene passato al blocco Finally, indipendentemente dalla modalità di uscita dal blocco Try...Catch.

Il codice incluso in un blocco Finally viene eseguito anche se si incontra un'istruzione Return in un blocco Try o Catch. Il controllo non viene passato da un blocco Try o Catch al blocco Finally corrispondente nei seguenti casi:

Un'Istruzione End viene rilevata nel blocco Try o Catch.
Un'eccezione StackOverflowException viene generata nel blocco Try o Catch.

Non è valido trasferire in modo esplicito l'esecuzione in un blocco Finally. Non è inoltre consentito trasferire l'esecuzione all'esterno di un blocco Finally, tranne con un'eccezione.

Se un'istruzione Try non contiene almeno un blocco Catch, deve contenere un blocco Finally.

Suggerimento
Se non è necessario rilevare eccezioni specifiche, il comportamento dell'istruzione Using è identico a quello di un blocco Try…Finally e viene garantita l'eliminazione delle risorse, a prescindere dalla modalità di uscita dal blocco. Questo meccanismo è valido anche per le eccezioni non gestite. Per ulteriori informazioni, vedere Istruzione Using (Visual Basic).

Argomento Exception

L'argomento exception del blocco Catch è un'istanza della classe Exception oppure una classe che deriva dalla classe Exception. L'istanza della classe Exception corrisponde all'errore verificatosi nel blocco Try.

Le proprietà dell'oggetto Exception consentono di identificare la causa e il percorso di un'eccezione. Ad esempio, nella proprietà StackTrace sono elencati i metodi chiamati che hanno causato l'eccezione, in modo da consentire di individuare il punto del codice in cui si è verificato l'errore. Tramite la proprietà Message viene restituito un messaggio in cui viene descritta l'eccezione. Tramite la proprietà HelpLink viene restituito un collegamento a un file della Guida associato. Tramite la proprietà InnerException viene restituito l'oggetto Exception mediante il quale è stata causata l'eccezione corrente oppure viene restituito Nothing se non è presente alcun oggetto Exception originale.

Considerazioni in caso di utilizzo di un blocco Try...Catch

Utilizzare un'istruzione Try…Catch solo segnalare il verificarsi di eventi anomali o imprevisti. Di seguito sono elencati alcuni dei motivi:

Il rilevamento di eccezioni in fase di esecuzione crea sovraccarico aggiuntivo e probabilmente risulta più lento rispetto a un controllo preventivo per evitare le eccezioni.
Se un blocco Catch non viene gestito correttamente, l'eccezione potrebbe non essere segnalata correttamente agli utenti.
La gestione delle eccezioni rende più complesso un programma.

Non sempre è necessaria un'istruzione Try…Catch per controllare una condizione che è probabile si verifichi. Nell'esempio seguente viene verificata l'esistenza di un file prima di tentarne l'apertura. In tal modo, la necessità di rilevare un'eccezione generata dal metodo OpenText si riduce.

Private Sub TextFileExample(ByVal filePath As String)

    ' Verify that the file exists.
    If System.IO.File.Exists(filePath) = False Then
        Console.Write("File Not Found: " & filePath)
    Else
        ' Open the text file and display its contents.
        Dim sr As System.IO.StreamReader =
            System.IO.File.OpenText(filePath)

        Console.Write(sr.ReadToEnd)

        sr.Close()
    End If
End Sub

Assicurarsi che il codice nei blocchi Catch consenta di segnalare correttamente le eccezioni agli utenti, tramite l'accesso thread-safe o messaggi appropriati. In caso contrario, le eccezioni potrebbero rimanere sconosciute.

Situazioni parzialmente attendibili

Nelle situazioni di attendibilità parziale, ad esempio un'applicazione ospitata in una condivisione di rete, la struttura Try...Catch...Finally non intercetta le eccezioni di sicurezza che si verificano prima che venga richiamato il metodo contenente la chiamata. Nell'esempio riportato di seguito, se l'istruzione viene inserita su una condivisione server ed eseguita da tale posizione, verrà generato l'errore "System.Security.SecurityException: Richiesta non riuscita". Per ulteriori informazioni sulle eccezioni di sicurezza, vedere la classe SecurityException.

Try
    Process.Start("https://www.microsoft.com")
Catch ex As Exception
    MsgBox("Can't load Web page" & vbCrLf & ex.Message)
End Try

In una situazione di attendibilità parziale di questo tipo, è necessario inserire l'istruzione Process.Start in un'istruzione Sub separata. La chiamata iniziale a Sub avrà esito negativo. In questo modo, l'istruzione Try...Catch potrà intercettarlo prima che venga avviato l'oggetto Sub contenente Process.Start e prodotta l'eccezione di sicurezza.

Esempio

Nell'esempio riportato di seguito viene illustrata la struttura dell'istruzione Try...Catch...Finally.

Public Sub TryExample()
    ' Declare variables.
    Dim x As Integer = 5
    Dim y As Integer = 0

    ' Set up structured error handling.
    Try
        ' Cause a "Divide by Zero" exception.
        x = x \ y

        ' This statement does not execute because program
        ' control passes to the Catch block when the
        ' exception occurs.
        MessageBox.Show("end of Try block")
    Catch ex As Exception
        ' Show the exception's message.
        MessageBox.Show(ex.Message)

        ' Show the stack trace, which is a list of methods
        ' that are currently executing.
        MessageBox.Show("Stack Trace: " & vbCrLf & ex.StackTrace)
    Finally
        ' This line executes whether or not the exception occurs.
        MessageBox.Show("in Finally block")
    End Try
End Sub

Nell'esempio seguente, tramite il metodo CreateException viene generata un'eccezione NullReferenceException. Il codice tramite il quale viene generata l'eccezione non è in un blocco Try. Pertanto, il metodo CreateException non consente la gestione dell'eccezione. L'eccezione viene gestita tramite il metodo RunSample poiché la chiamata al metodo CreateException è in un blocco Try.

Nell'esempio vengono incluse le istruzioni Catch per diversi tipi di eccezioni, ordinate dalla più specifica alla più generale.

Public Sub RunSample()
    Try
        CreateException()
    Catch ex As System.IO.IOException
        ' Code that reacts to IOException.
    Catch ex As NullReferenceException
        MessageBox.Show("NullReferenceException: " & ex.Message)
        MessageBox.Show("Stack Trace: " & vbCrLf & ex.StackTrace)
    Catch ex As Exception
        ' Code that reacts to any other exception.
    End Try
End Sub

Private Sub CreateException()
    ' This code throws a NullReferenceException.
    Dim obj = Nothing
    Dim prop = obj.Name

    ' This code also throws a NullReferenceException.
    'Throw New NullReferenceException("Something happened.")
End Sub

Nell'esempio seguente viene mostrato come utilizzare un'istruzione Catch When per filtrare un'espressione condizionale. Se l'espressione condizionale restituisce True, viene eseguito il codice nel blocco Catch.

Private Sub WhenExample()
    Dim i As Integer = 5

    Try
        Throw New ArgumentException()
    Catch e As OverflowException When i = 5
        Console.WriteLine("First handler")
    Catch e As ArgumentException When i = 4
        Console.WriteLine("Second handler")
    Catch When i = 5
        Console.WriteLine("Third handler")
    End Try
End Sub
' Output: Third handler

Nell'esempio seguente è presente un'istruzione Try…Catch contenuta in un blocco Try. Tramite il blocco Catch interno viene generata un'eccezione la cui proprietà InnerException è impostata sull'eccezione originale. Tramite il blocco Catch esterno vengono segnalate l'eccezione propria del blocco e quella interna.

Private Sub InnerExceptionExample()
    Try
        Try
            ' Set a reference to a StringBuilder.
            ' The exception below does not occur if the commented
            ' statement is used instead.
            Dim sb As System.Text.StringBuilder
            'Dim sb As New System.Text.StringBuilder

            ' Cause a NullReferenceException.
            sb.Append("text")
        Catch ex As Exception
            ' Throw a new exception that has the inner exception
            ' set to the original exception.
            Throw New ApplicationException("Something happened :(", ex)
        End Try
    Catch ex2 As Exception
        ' Show the exception.
        Console.WriteLine("Exception: " & ex2.Message)
        Console.WriteLine(ex2.StackTrace)

        ' Show the inner exception, if one is present.
        If ex2.InnerException IsNot Nothing Then
            Console.WriteLine("Inner Exception: " & ex2.InnerException.Message)
            Console.WriteLine(ex2.StackTrace)
        End If
    End Try
End Sub

Vedere anche

Cronologia delle modifiche

Data

Cronologia

Motivo

Aprile 2011

È stata eseguita la riorganizzazione e sono stati aggiunti esempi.

Miglioramento delle informazioni.

Condividi tramite