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

Fournit un moyen de gérer certaines ou toutes les erreurs possibles qui peuvent se produire dans un bloc donné du code, tout code en cours d’exécution.Provides a way to handle some or all possible errors that may occur in a given block of code, while still running code.

SyntaxeSyntax

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

ComposantsParts

TermeTerm DéfinitionDefinition
tryStatements Facultatif.Optional. Instructions où une erreur peut se produire.Statement(s) where an error can occur. Il peut s'agir d'une instruction composée.Can be a compound statement.
Catch Facultatif.Optional. Plusieurs Catch blocs autorisés.Multiple Catch blocks permitted. Si une exception se produit lors du traitement de la Try bloquer, chacun Catch instruction est examinée dans l’ordre textuel afin de déterminer si elle gère l’exception, avec exception représentant l’exception qui a été levée.If an exception occurs when processing the Try block, each Catch statement is examined in textual order to determine whether it handles the exception, with exception representing the exception that has been thrown.
exception Facultatif.Optional. Tout nom de variable.Any variable name. La valeur initiale de l'argument exception est la valeur de l'erreur levée.The initial value of exception is the value of the thrown error. Utilisé avec Catch pour spécifier l’erreur interceptée.Used with Catch to specify the error caught. Si omis, la Catch instruction intercepte toute exception.If omitted, the Catch statement catches any exception.
type Facultatif.Optional. Spécifie le type de filtre de la classe.Specifies the type of class filter. Si la valeur de exception est du type spécifié par type ou d’un type dérivé, l’identificateur est lié à l’objet exception.If the value of exception is of the type specified by type or of a derived type, the identifier becomes bound to the exception object.
When Facultatif.Optional. Un Catch instruction avec un When clause intercepte les exceptions uniquement lorsque expression prend la valeur True.A Catch statement with a When clause catches exceptions only when expression evaluates to True. Un When clause est appliquée uniquement après la vérification du type de l’exception, et expression peut faire référence à l’identificateur qui représente l’exception.A When clause is applied only after checking the type of the exception, and expression may refer to the identifier representing the exception.
expression Facultatif.Optional. Doit être implicitement convertible en Boolean.Must be implicitly convertible to Boolean. Toute expression qui décrit un filtre générique.Any expression that describes a generic filter. Généralement utilisé pour filtrer par numéro d’erreur.Typically used to filter by error number. Utilisé avec When mot clé pour spécifier les circonstances dans lesquelles l’erreur est interceptée.Used with When keyword to specify circumstances under which the error is caught.
catchStatements Facultatif.Optional. Instructions permettant de gérer les erreurs qui se produisent dans associé Try bloc.Statement(s) to handle errors that occur in the associated Try block. Il peut s'agir d'une instruction composée.Can be a compound statement.
Exit Try Facultatif.Optional. Mot clé qui décompose le Try...Catch...Finally structure.Keyword that breaks out of the Try...Catch...Finally structure. L’exécution reprend avec le code qui suit immédiatement la End Try instruction.Execution resumes with the code immediately following the End Try statement. La Finally instruction sera exécutée.The Finally statement will still be executed. Interdit dans Finally blocs.Not allowed in Finally blocks.
Finally Facultatif.Optional. Un Finally bloc est toujours exécuté quand l’exécution quitte une partie de la Try...Catch instruction.A Finally block is always executed when execution leaves any part of the Try...Catch statement.
finallyStatements Facultatif.Optional. Instructions qui sont exécutées une fois que tout autre traitement d’erreur s’est produite.Statement(s) that are executed after all other error processing has occurred.
End Try Met fin à la Try...Catch...Finally structure.Terminates the Try...Catch...Finally structure.

NotesRemarks

Si vous pensez qu’une exception particulière se produise pendant une section particulière de code, placez le code dans un Try bloquer et utiliser un Catch bloc pour garder le contrôle et de gérer l’exception si elle se produit.If you expect that a particular exception might occur during a particular section of code, put the code in a Try block and use a Catch block to retain control and handle the exception if it occurs.

Un Try…Catch instruction se compose d’un Try bloc suivie d’une ou plusieurs Catch clauses qui spécifient des gestionnaires pour différentes exceptions.A Try…Catch statement consists of a Try block followed by one or more Catch clauses, which specify handlers for various exceptions. Lorsqu’une exception est levée dans un Try bloquer, Visual Basic recherche le Catch instruction qui gère l’exception.When an exception is thrown in a Try block, Visual Basic looks for the Catch statement that handles the exception. Si une correspondance Catch instruction n’est pas trouvée, Visual Basic examine la méthode qui a appelé la méthode actuelle, et ainsi de suite la pile des appels.If a matching Catch statement is not found, Visual Basic examines the method that called the current method, and so on up the call stack. Si aucun Catch bloc est trouvé, Visual Basic affiche un message d’exception non prise en charge pour l’utilisateur et arrête l’exécution du programme.If no Catch block is found, Visual Basic displays an unhandled exception message to the user and stops execution of the program.

Vous pouvez utiliser plusieurs Catch instruction dans un Try…Catch instruction.You can use more than one Catch statement in a Try…Catch statement. Dans ce cas, l’ordre de la Catch clauses est important, car ils sont examinés dans l’ordre.If you do this, the order of the Catch clauses is significant because they are examined in order. Interceptez les exceptions plus spécifiques avant les moins spécifiques.Catch the more specific exceptions before the less specific ones.

Ce qui suit Catch conditions de l’instruction sont les moins spécifiques et intercepte toutes les exceptions qui dérivent de la Exception classe.The following Catch statement conditions are the least specific, and will catch all exceptions that derive from the Exception class. Vous devez normalement utiliser une de ces variations comme dernier Catch bloquer le Try...Catch...Finally structure, après l’interception de toutes les exceptions spécifiques que vous attendez.You should ordinarily use one of these variations as the last Catch block in the Try...Catch...Finally structure, after catching all the specific exceptions you expect. Flux de contrôle ne peut jamais atteindre un Catch bloc qui suit une de ces variantes.Control flow can never reach a Catch block that follows either of these variations.

  • Le type est Exception, par exemple : Catch ex As ExceptionThe type is Exception, for example: Catch ex As Exception

  • L’instruction n’a aucun exception variable, par exemple : CatchThe statement has no exception variable, for example: Catch

Quand un Try…Catch…Finally instruction est imbriquée dans une autre Try bloc, Visual Basic examine tout d’abord chaque Catch instruction dans la plus intérieure Try bloc.When a Try…Catch…Finally statement is nested in another Try block, Visual Basic first examines each Catch statement in the innermost Try block. Si aucune correspondance Catch instruction est trouvée, la recherche se poursuit à le Catch instructions d’externe Try…Catch…Finally bloc.If no matching Catch statement is found, the search proceeds to the Catch statements of the outer Try…Catch…Finally block.

Les variables locales à partir d’un Try bloc ne sont pas disponibles dans un Catch bloqué, car ils sont des blocs séparés.Local variables from a Try block are not available in a Catch block because they are separate blocks. Si vous souhaitez utiliser une variable dans plusieurs blocs, déclarez la variable en dehors de la Try...Catch...Finally structure.If you want to use a variable in more than one block, declare the variable outside the Try...Catch...Finally structure.

Conseil

La Try…Catch…Finally instruction est disponible en tant qu’un extrait de code IntelliSense.The Try…Catch…Finally statement is available as an IntelliSense code snippet. Dans le Gestionnaire des extraits de Code, développez modèles de Code - If, For Each, Try Catch, propriété, etc., puis (Exceptions) de gestion des erreurs.In the Code Snippets Manager, expand Code Patterns - If, For Each, Try Catch, Property, etc, and then Error Handling (Exceptions). Pour plus d’informations, consultez Extraits de code.For more information, see Code Snippets.

Bloc finallyFinally block

Si vous avez une ou plusieurs instructions qui doivent s’exécuter avant de quitter le Try structure, utilisez un Finally bloc.If you have one or more statements that must run before you exit the Try structure, use a Finally block. Le contrôle passe à la Finally bloquer juste avant de sortir de la Try…Catch structure.Control passes to the Finally block just before it passes out of the Try…Catch structure. Cela est vrai même si une exception se produit n’importe où à l’intérieur de la Try structure.This is true even if an exception occurs anywhere inside the Try structure.

Un Finally bloc est utile pour l’exécution de tout code qui doit s’exécuter même s’il existe une exception.A Finally block is useful for running any code that must execute even if there is an exception. Le contrôle est passé à la Finally bloc quelle que soit la façon dont le Try...Catch bloquer se ferme.Control is passed to the Finally block regardless of how the Try...Catch block exits.

Le code dans un Finally bloque s’exécute même si votre code rencontre une Return instruction dans un Try ou Catch bloc.The code in a Finally block runs even if your code encounters a Return statement in a Try or Catch block. Contrôle ne passe pas d’un Try ou Catch bloquer correspondant Finally bloquer dans les cas suivants :Control does not pass from a Try or Catch block to the corresponding Finally block in the following cases:

Il n’est pas valide pour transférer explicitement l’exécution dans un Finally bloc.It is not valid to explicitly transfer execution into a Finally block. Transfert de l’exécution hors d’un Finally bloc n’est pas valide, sauf via une exception.Transferring execution out of a Finally block is not valid, except through an exception.

Si un Try instruction ne contient-elle pas au moins un Catch bloc, il doit contenir un Finally bloc.If a Try statement does not contain at least one Catch block, it must contain a Finally block.

Conseil

Si vous n’avez pas intercepter des exceptions spécifiques, le Using instruction se comporte comme un Try…Finally bloc et garantit l’élimination des ressources, quel que soit la manière dont vous quittez le bloc.If you do not have to catch specific exceptions, the Using statement behaves like a Try…Finally block, and guarantees disposal of the resources, regardless of how you exit the block. Cela est vrai même avec une exception non gérée.This is true even with an unhandled exception. Pour plus d’informations, consultez using, instruction.For more information, see Using Statement.

Argument d’exceptionException argument

Le Catch bloc exception argument est une instance de la Exception classe ou une classe qui dérive de la Exception classe.The Catch block exception argument is an instance of the Exception class or a class that derives from the Exception class. Le Exception instance de classe correspond à l’erreur qui s’est produite dans le Try bloc.The Exception class instance corresponds to the error that occurred in the Try block.

Les propriétés de la Exception aide à identifier la cause et l’emplacement d’une exception de l’objet.The properties of the Exception object help to identify the cause and location of an exception. Par exemple, le StackTrace propriété répertorie les méthodes appelées qui a conduit à l’exception, ce qui vous aide à trouver où l’erreur s’est produite dans le code.For example, the StackTrace property lists the called methods that led to the exception, helping you find where the error occurred in the code. Message Retourne un message qui décrit l’exception.Message returns a message that describes the exception. HelpLink Renvoie un lien vers un fichier d’aide associé.HelpLink returns a link to an associated Help file. InnerException Retourne le Exception objet qui a provoqué l’exception actuelle, ou elle retourne Nothing s’il n’existe aucun original Exception.InnerException returns the Exception object that caused the current exception, or it returns Nothing if there is no original Exception.

Considérations sur l’utilisation d’un bloc Try... Catch, instructionConsiderations when using a Try…Catch statement

Utilisez un Try…Catch instruction uniquement pour signaler la présence d’événements inhabituels ou imprévus.Use a Try…Catch statement only to signal the occurrence of unusual or unanticipated program events. Pour cela les raisons suivantes :Reasons for this include the following:

  • Interception des exceptions lors de l’exécution crée une charge supplémentaire et est susceptible d’être plus lent que pré-vérification pour éviter les exceptions.Catching exceptions at runtime creates additional overhead, and is likely to be slower than pre-checking to avoid exceptions.

  • Si un Catch bloc n’est pas traitée correctement, l’exception peuvent ne pas être déclarée correctement pour les utilisateurs.If a Catch block is not handled correctly, the exception might not be reported correctly to users.

  • Gestion des exceptions rend plus complexe.Exception handling makes a program more complex.

Vous n’avez pas toujours besoin un Try…Catch instruction pour vérifier une condition qui est susceptible de se produire.You do not always need a Try…Catch statement to check for a condition that is likely to occur. L’exemple suivant vérifie l’existence d’un fichier avant d’essayer de l’ouvrir.The following example checks whether a file exists before trying to open it. Cela réduit la nécessité d’intercepter une exception levée par le OpenText (méthode).This reduces the need for catching an exception thrown by the OpenText method.

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

Assurez-vous que le code de Catch blocs peuvent correctement signaler les exceptions aux utilisateurs, via la journalisation thread-safe ou les messages appropriés.Ensure that code in Catch blocks can properly report exceptions to users, whether through thread-safe logging or appropriate messages. Sinon, les exceptions pourraient rester inconnues.Otherwise, exceptions might remain unknown.

Méthodes AsyncAsync methods

Si vous marquez une méthode avec le Async modificateur, vous pouvez utiliser la Await opérateur dans la méthode.If you mark a method with the Async modifier, you can use the Await operator in the method. Une instruction avec le Await opérateur suspend l’exécution de la méthode jusqu'à ce que la tâche attendue se termine.A statement with the Await operator suspends execution of the method until the awaited task completes. La tâche représente un travail en cours.The task represents ongoing work. Lorsque la tâche qui est associée la Await opérateur terminée, l’exécution reprend dans la même méthode.When the task that's associated with the Await operator finishes, execution resumes in the same method. Pour plus d’informations, consultez flux de contrôle dans les programmes Async.For more information, see Control Flow in Async Programs.

Une tâche retournée par une méthode Async peut se terminer par un état d’erreur, indiquant qu’il est terminé en raison d’une exception non gérée.A task returned by an Async method may end in a faulted state, indicating that it completed due to an unhandled exception. Une tâche peut également se terminer dans un état annulé, ce qui entraîne un OperationCanceledException levée en dehors de l’expression await.A task may also end in a canceled state, which results in an OperationCanceledException being thrown out of the await expression. Pour intercepter un type d’exception, placez le Await expression qui est associé à la tâche dans un Try bloquer et intercepter l’exception dans le Catch bloc.To catch either type of exception, place the Await expression that's associated with the task in a Try block, and catch the exception in the Catch block. Un exemple est fourni plus loin dans cette rubrique.An example is provided later in this topic.

Une tâche peut être dans un état d’erreur, car plusieurs exceptions ont été responsables de sa défaillance.A task can be in a faulted state because multiple exceptions were responsible for its faulting. Par exemple, la tâche peut être le résultat d'un appel à Task.WhenAll.For example, the task might be the result of a call to Task.WhenAll. Lorsque vous attendez une telle tâche, l’exception interceptée est uniquement une des exceptions, et vous ne pouvez pas prédire quelle exception est interceptée.When you await such a task, the caught exception is only one of the exceptions, and you can't predict which exception will be caught. Un exemple est fourni plus loin dans cette rubrique.An example is provided later in this topic.

Un Await expression ne peut pas être à l’intérieur d’un Catch bloc ou Finally bloc.An Await expression can't be inside a Catch block or Finally block.

IteratorsIterators

Une fonction d’itérateur ou Get accesseur effectue une itération personnalisée sur une collection.An iterator function or Get accessor performs a custom iteration over a collection. Un itérateur utilise une Yield instruction pour retourner chaque élément de la collection un à la fois.An iterator uses a Yield statement to return each element of the collection one at a time. Vous appelez une fonction d’itérateur en utilisant un For Each... L’instruction suivante.You call an iterator function by using a For Each...Next Statement.

Un Yield instruction peut être à l’intérieur d’un Try bloc.A Yield statement can be inside a Try block. Un Try bloc qui contient un Yield instruction peut avoir Catch bloque et peut avoir un Finally bloc.A Try block that contains a Yield statement can have Catch blocks, and can have a Finally block. Consultez la section « Essayez de blocs dans Visual Basic » de itérateurs pour obtenir un exemple.See the "Try Blocks in Visual Basic" section of Iterators for an example.

Un Yield instruction ne peut pas être à l’intérieur d’un Catch bloc ou une Finally bloc.A Yield statement cannot be inside a Catch block or a Finally block.

Si le For Each corps (en dehors de la fonction d’itérateur) lève une exception, un Catch bloc dans la fonction d’itérateur n’est pas exécuté, mais un Finally bloc dans la fonction d’itérateur est exécuté.If the For Each body (outside of the iterator function) throws an exception, a Catch block in the iterator function is not executed, but a Finally block in the iterator function is executed. Un Catch bloc à l’intérieur d’une fonction d’itérateur intercepte uniquement les exceptions qui se produisent à l’intérieur de la fonction d’itérateur.A Catch block inside an iterator function catches only exceptions that occur inside the iterator function.

Situations de confiance partiellePartial-trust situations

Dans les situations de confiance partielle, tel qu’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 l’appel de la méthode qui contient l’appel.In partial-trust situations, such as an application hosted on a network share, Try...Catch...Finally does not catch security exceptions that occur before the method that contains the call is invoked. L’exemple suivant, lorsque vous placez sur un partage de serveur et que vous exécutez à partir de là, génère l’erreur « System.Security.SecurityException : Échoué de la demande. »The following example, when you put it on a server share and run from there, produces the error "System.Security.SecurityException: Request Failed." Pour plus d’informations sur les exceptions de sécurité, consultez la SecurityException classe.For more information about security exceptions, see the SecurityException class.

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

Dans une telle situation de confiance partielle, vous devez placer le Process.Start instruction dans une fonction Sub.In such a partial-trust situation, you have to put the Process.Start statement in a separate Sub. L’appel initial à la Sub échoue.The initial call to the Sub will fail. Cela permet de Try...Catch de l’intercepter avant le Sub contenant Process.Start est démarré et généré l’exception de sécurité.This enables Try...Catch to catch it before the Sub that contains Process.Start is started and the security exception produced.

ExemplesExamples

La structure de Try... Catch... EnfinThe structure of Try...Catch...Finally

L’exemple suivant illustre la structure de la Try...Catch...Finally instruction.The following example illustrates the structure of the Try...Catch...Finally statement.

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

Exception dans une méthode appelée à partir d’un bloc TryException in a method called from a Try block

Dans l’exemple suivant, le CreateException méthode lève un NullReferenceException.In the following example, the CreateException method throws a NullReferenceException. Le code qui génère l’exception n’est pas dans un Try bloc.The code that generates the exception is not in a Try block. Par conséquent, le CreateException méthode ne gère pas l’exception.Therefore, the CreateException method does not handle the exception. Le RunSample méthode gère l’exception, car l’appel à la CreateException méthode se trouve dans un Try bloc.The RunSample method does handle the exception because the call to the CreateException method is in a Try block.

L’exemple inclut Catch instructions pour plusieurs types d’exceptions, classées de la plus spécifique au plus général.The example includes Catch statements for several types of exceptions, ordered from the most specific to the most general.

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’instruction Catch lorsqueThe Catch When statement

L’exemple suivant montre comment utiliser un Catch When instruction pour filtrer sur une expression conditionnelle.The following example shows how to use a Catch When statement to filter on a conditional expression. Si l’expression conditionnelle a la valeur True, le code dans le Catch bloquer s’exécute.If the conditional expression evaluates to True, the code in the Catch block runs.

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

Instructions Try imbriquéesNested Try statements

L’exemple suivant comprend un Try…Catch instruction qui est contenue dans un Try bloc.The following example has a Try…Catch statement that is contained in a Try block. Interne Catch bloc lève une exception qui a son InnerException propriété définie à l’exception d’origine.The inner Catch block throws an exception that has its InnerException property set to the original exception. Externe Catch bloc signale sa propre exception et l’exception interne.The outer Catch block reports its own exception and the inner exception.

Private Sub InnerExceptionExample()
    Try
        Try
            ' Set a reference to a StringBuilder.
            ' The exception below does not occur if the commented
            ' out 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

Gestion des exceptions pour les méthodes asyncException handling for async methods

L'exemple suivant illustre la gestion des exceptions pour les méthodes async.The following example illustrates exception handling for async methods. Pour intercepter une exception qui s’applique à une tâche asynchrone, le Await expression est dans un Try bloc de l’appelant et l’exception est interceptée dans le Catch bloc.To catch an exception that applies to an async task, the Await expression is in a Try block of the caller, and the exception is caught in the Catch block.

Supprimez les marques de commentaire de la ligne Throw New Exception dans l'exemple pour illustrer la gestion des exceptions.Uncomment the Throw New Exception line in the example to demonstrate exception handling. L’exception est interceptée dans le Catch bloquer, de la tâche IsFaulted propriété est définie sur Trueet de la tâche Exception.InnerException propriété est définie à l’exception.The exception is caught in the Catch block, the task's IsFaulted property is set to True, and the task's Exception.InnerException property is set to the exception.

Supprimez les marques de commentaire de la ligne Throw New OperationCancelledException pour montrer ce qui se passe quand vous annulez un processus asynchrone.Uncomment the Throw New OperationCancelledException line to demonstrate what happens when you cancel an asynchronous process. L’exception est interceptée dans le Catch bloc et de la tâche IsCanceled propriété est définie sur True.The exception is caught in the Catch block, and the task's IsCanceled property is set to True. Toutefois, dans certaines conditions qui s’appliquent à cet exemple, IsFaulted a la valeur True et IsCanceled est défini sur False.However, under some conditions that don't apply to this example, IsFaulted is set to True and IsCanceled is set to False.

Public Async Function DoSomethingAsync() As Task
    Dim theTask As Task(Of String) = DelayAsync()

    Try
        Dim result As String = Await theTask
        Debug.WriteLine("Result: " & result)
    Catch ex As Exception
        Debug.WriteLine("Exception Message: " & ex.Message)
    End Try

    Debug.WriteLine("Task IsCanceled: " & theTask.IsCanceled)
    Debug.WriteLine("Task IsFaulted:  " & theTask.IsFaulted)
    If theTask.Exception IsNot Nothing Then
        Debug.WriteLine("Task Exception Message: " &
            theTask.Exception.Message)
        Debug.WriteLine("Task Inner Exception Message: " &
            theTask.Exception.InnerException.Message)
    End If
End Function

Private Async Function DelayAsync() As Task(Of String)
    Await Task.Delay(100)

    ' Uncomment each of the following lines to
    ' demonstrate exception handling.

    'Throw New OperationCanceledException("canceled")
    'Throw New Exception("Something happened.")
    Return "Done"
End Function


' Output when no exception is thrown in the awaited method:
'   Result: Done
'   Task IsCanceled: False
'   Task IsFaulted:  False

' Output when an Exception is thrown in the awaited method:
'   Exception Message: Something happened.
'   Task IsCanceled: False
'   Task IsFaulted:  True
'   Task Exception Message: One or more errors occurred.
'   Task Inner Exception Message: Something happened.

' Output when an OperationCanceledException or TaskCanceledException
' is thrown in the awaited method:
'   Exception Message: canceled
'   Task IsCanceled: True
'   Task IsFaulted:  False

Gestion des exceptions multiples dans les méthodes asyncHandling multiple exceptions in async methods

L’exemple suivant illustre la gestion des exceptions quand plusieurs tâches peuvent entraîner plusieurs exceptions.The following example illustrates exception handling where multiple tasks can result in multiple exceptions. Le Try bloc a le Await expression pour la tâche qui Task.WhenAll retourné.The Try block has the Await expression for the task that Task.WhenAll returned. La tâche est terminée lorsque les trois tâches auquel Task.WhenAll est appliqué sont terminées.The task is complete when the three tasks to which Task.WhenAll is applied are complete.

Chacune de ces trois tâches provoque une exception.Each of the three tasks causes an exception. Le Catch bloc effectue une itération dans les exceptions qui se trouvent dans le Exception.InnerExceptions propriété de la tâche qui Task.WhenAll retourné.The Catch block iterates through the exceptions, which are found in the Exception.InnerExceptions property of the task that Task.WhenAll returned.

Public Async Function DoMultipleAsync() As Task
    Dim theTask1 As Task = ExcAsync(info:="First Task")
    Dim theTask2 As Task = ExcAsync(info:="Second Task")
    Dim theTask3 As Task = ExcAsync(info:="Third Task")

    Dim allTasks As Task = Task.WhenAll(theTask1, theTask2, theTask3)

    Try
        Await allTasks
    Catch ex As Exception
        Debug.WriteLine("Exception: " & ex.Message)
        Debug.WriteLine("Task IsFaulted: " & allTasks.IsFaulted)
        For Each inEx In allTasks.Exception.InnerExceptions
            Debug.WriteLine("Task Inner Exception: " + inEx.Message)
        Next
    End Try
End Function

Private Async Function ExcAsync(info As String) As Task
    Await Task.Delay(100)

    Throw New Exception("Error-" & info)
End Function

' Output:
'   Exception: Error-First Task
'   Task IsFaulted: True
'   Task Inner Exception: Error-First Task
'   Task Inner Exception: Error-Second Task
'   Task Inner Exception: Error-Third Task

Voir aussiSee also