Try...Catch...Finally, instruction (Visual Basic)

Article
08/10/2011

Permet de traiter une partie ou l'ensemble des erreurs possibles pouvant se produire dans un bloc de code donné, tout en continuant à exécuter le code.

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

Éléments

Terme	Définition
tryStatements	Facultatif. Instructions dans lesquelles une erreur peut se produire. Il peut s'agir d'une instruction composée.
Catch	Facultatif. Plusieurs blocs Catch sont autorisés. Si une exception se produit pendant le traitement du bloc Try, chaque instruction Catch est examinée dans l'ordre textuel afin de déterminer si elle gère cette exception, exception représentant l'exception qui a été levée.
exception	Facultatif. Tout nom de variable. La valeur initiale de l'argument exception est la valeur de l'erreur levée. Cet argument est utilisé avec Catch pour spécifier l'erreur interceptée. S'il est omis, l'instruction Catch intercepte n'importe quelle exception.
type	Facultatif. Spécifie le type d'un filtre de classe. Si la valeur de l'argument exception est l'un des types spécifiés par type ou un type dérivé, l'identificateur est lié à l'objet exception.
When	Facultatif. Une instruction Catch avec une clause When intercepte les exceptions uniquement lorsque expression a la valeur True. Une clause When n'est appliquée qu'après le contrôle du type de l'exception, et expression peut faire référence à l'identificateur qui représente l'exception.
expression	Facultatif. Doit pouvoir être converti implicitement en type Boolean. Toute expression qui décrit un filtre générique. Généralement utilisé pour effectuer un filtre selon le numéro de l'erreur. Cet argument est utilisé avec le mot clé When pour spécifier des circonstances permettant d'intercepter l'erreur.
catchStatements	Facultatif. Instruction(s) permettant de gérer des erreurs se produisant dans le bloc Try associé. Il peut s'agir d'une instruction composée.
Exit Try	Facultatif. Mot clé qui décompose la structure Try...Catch...Finally. L'exécution reprend par le code qui suit immédiatement l'instruction End Try. L'instruction Finally sera toujours exécutée. Non autorisé dans les blocs Finally.
Finally	Facultatif. Un bloc Finally est toujours exécuté quand l'exécution quitte une partie quelconque de l'instruction Try...Catch.
finallyStatements	Facultatif. Instructions qui sont exécutées à la fin du traitement de toutes les autres erreurs.
End Try	Met fin à la structure Try...Catch...Finally.

Notes

Si vous vous attendez à ce qu'une exception particulière se produise pendant une section particulière de code, mettez le code dans un bloc Try et utilisez un bloc Catch pour conserver le contrôle et gérer l'exception si elle se produit.

Une instruction Try…Catch est un bloc Try suivi par une ou plusieurs clauses Catch, qui spécifient les gestionnaires de diverses exceptions. Lorsqu'une exception est levée dans un bloc Try, Visual Basic recherche l'instruction Catch qui gère l'exception. Si une instruction Catch correspondante n'est pas trouvée, Visual Basic examine la méthode qui a appelé la méthode actuelle, et ainsi de suite dans la pile des appels. Si aucun bloc Catch n'est trouvé, Visual Basic affiche un message d'exception non gérée destiné à l'utilisateur et arrête l'exécution du programme.

Vous pouvez utiliser plusieurs instructions Catch dans une instruction Try…Catch. Si vous faites cela, l'ordre des clauses Catch est important car celles-ci sont examinées dans l'ordre. Interceptez les exceptions les plus spécifiques avant celles qui le sont le moins.

Les conditions de l'instruction Catch suivantes sont les moins spécifiques et intercepteront toutes les exceptions dérivant de la classe Exception. Vous devez normalement utiliser l'une de ces variations comme dernier bloc Catch dans la structure Try...Catch...Finally, après avoir intercepté toutes les exceptions spécifiques que vous prévoyez. Le flux de contrôle ne peut jamais atteindre un bloc Catch qui suit l'une de ces variations.

type a la valeur Exception, par exemple : Catch ex As Exception
L'instruction n'a aucune variable exception, par exemple : Catch

Lorsqu'une instruction Try…Catch…Finally est imbriquée dans un autre bloc Try, Visual Basic examine d'abord chaque instruction Catch dans le bloc Try le plus profond. Si aucune instruction Catch correspondante n'est trouvée, la recherche se poursuit aux instructions Catch du bloc externe Try…Catch…Finally.

Les variables locales d'un bloc Try ne sont pas disponibles dans un bloc Catch, car ce sont des blocs séparés. Si vous voulez utiliser une variable dans plusieurs blocs, déclarez la variable à l'extérieur de la structure Try...Catch...Finally.

Conseil

L'instruction Try…Catch…Finally est disponible sous forme d'extrait de code IntelliSense. Dans le Gestionnaire des extraits de code, développez Modèles de code - If, For Each, Try Catch, Property, etc., puis Gestion des erreurs (Exceptions). Pour plus d'informations, consultez Comment : insérer des extraits de code IntelliSense.

Bloc Finally

Si une ou plusieurs instructions doivent être exécutées avant que vous ne sortiez de la structure Try, utilisez un bloc Finally. Le contrôle passe au bloc Finally juste avant de sortir de la structure Try…Catch. Cela est vrai même si une exception se produit où que ce soit dans la structure Try.

Un bloc Finally est utile pour l'exécution de tout code qui doit s'exécuter même en cas d'exception. Le contrôle est transmis au bloc Finally quelle que soit la méthode de sortie du bloc Try...Catch.

Le code dans un bloc Finally s'exécute même si votre code rencontre une instruction Return ou Try dans un bloc Catch ou . Le contrôle ne passe pas d'un bloc Try ou Catch au bloc Finally correspondant dans les cas suivants :

Une End, instruction est rencontrée dans le bloc Try ou Catch.
Une StackOverflowException est levée dans le bloc Try ou Catch.

Il n'est pas valide pour transférer explicitement l'exécution dans un bloc Finally. Elle est également valide pour transférer l'opération en dehors d'un bloc Finally sauf via une exception.

Si une instruction Try ne contient pas au moins un bloc Catch, elle doit contenir un bloc Finally.

Conseil

Si vous n'avez pas besoin d'intercepter des exceptions spécifiques, l'instruction Using se comporte comme un bloc Try…Finally et garantit l'élimination des ressources, quelle que soit la manière dont vous quittez le bloc. Cela est vrai même avec une exception non gérée. Pour plus d'informations, consultez Using, instruction (Visual Basic).

Argument d'exception

L'argument exception du bloc Catch est une instance de la classe Exception ou une classe qui dérive de la classe Exception. L'instance de la classe Exception correspond à l'erreur qui s'est produite dans le bloc Try.

Les propriétés de l'objet Exception permettent d'identifier la cause et l'emplacement d'une exception. Par exemple, la propriété StackTrace répertorie les méthodes appelées qui ont abouti à l'exception, ce qui vous permet de rechercher l'emplacement de l'erreur dans le code. Message renvoie un message qui décrit l'exception. HelpLink renvoie un lien vers un fichier d'aide associé. InnerException renvoie l'objet Exception qui a provoqué l'exception en cours, ou renvoie Nothing s'il n'existe aucune Exception originale.

Considérations sur l'utilisation d'une instruction Try…Catch

Utilisez une instruction Try…Catch uniquement pour signaler que des événements inhabituels ou imprévus se sont produits. Cette opération se produit pour les raisons suivantes :

L'interception d'exceptions lors de l'exécution crée une charge mémoire supplémentaire et est susceptible d'être plus lente que la pré-vérification pour éviter les exceptions.
Si un bloc Catch n'est pas correctement traité, l'exception ne sera peut-être pas rapportée de façon correcte aux utilisateurs.
La gestion des exceptions rend plus complexe un programme.

Une instruction Try…Catch n'est pas toujours nécessaire pour rechercher une condition qui risque probablement de se produire. L'exemple suivant vérifie si un fichier existe avant de tenter de l'ouvrir. Cela réduit la nécessité d'intercepter une exception levée par la méthode OpenText.

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

Veiller à ce que le code dans les blocs Catch puisse signaler correctement les exceptions aux utilisateurs, que ce soit par la journalisation thread-safe ou des messages appropriés. Sinon, les exceptions pourraient rester inconnues.

Situations d'un niveau de confiance partiel

Dans les situations d'un niveau de confiance partiel, comme une application hébergée sur un partage réseau, Try...Catch...Finally n'intercepte pas les exceptions de sécurité qui se produisent avant que la méthode qui contient l'appel ne soit appelée. L'exemple suivant, s'il est placé sur un partage réseau et exécuté à cet endroit, produit l'erreur : "System.Security.SecurityException: Échec de la demande". Pour plus d'informations sur les exceptions de sécurité, consultez 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

Dans la situation d'un niveau de confiance partiel, vous devez placer l'instruction Process.Start dans un Sub séparé. L'appel initial au Sub échoue. Cela permet à Try...Catch de l'intercepter avant le démarrage du Sub qui contient Process.Start et l'exécution de l'exception de sécurité.

Exemple

L'exemple ci-dessous illustre la structure de l'instruction 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

Dans l'exemple suivant, la méthode CreateException lève une NullReferenceException. Le code qui génère l'exception n'est pas dans un bloc Try. Par conséquent, la méthode CreateException ne gère pas l'exception. La méthode RunSample gère l'exception car l'appel à la méthode CreateException est dans un bloc Try.

L'exemple inclut des instructions Catch pour plusieurs types d'exceptions, classées de la plus spécifique à la plus générale.

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

L'exemple suivant montre comment utiliser une instruction Catch When pour filtrer sur une expression conditionnelle. Si l'expression conditionnelle a la valeur True, le code dans le bloc Catch s'exécute.

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

L'exemple suivant a une instruction Try…Catch contenue dans un bloc Try. Le bloc interne Catch lève une exception dont la propriété InnerException est définie sur l'exception d'origine. Le bloc Catch externe signale sa propre exception et l'exception interne.

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

Voir aussi

Historique des modifications

Date

Historique

Motif

Avril 2011

Réorganisation et ajout aux remarques, ajout d'exemples.

Améliorations apportées aux informations.