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 de code donné, tout en continuant d’exécuter du code.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

PartiesParts

TermeTerm DéfinitionDefinition
tryStatements Option facultative.Optional. Instruction (s) 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 Option facultative.Optional. Plusieurs blocs de Catch autorisés.Multiple Catch blocks permitted. Si une exception se produit lors du traitement du bloc Try, chaque instruction Catch est examinée dans l’ordre textuel pour 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 Option facultative.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. En cas d’omission, l’instruction Catch intercepte toute exception.If omitted, the Catch statement catches any exception.
type Option facultative.Optional. Spécifie le type de filtre de 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 d’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 Option facultative.Optional. Une instruction Catch avec une clause When 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. Une clause When est appliquée uniquement après avoir vérifié le type de l’exception, et expression peut faire référence à l’identificateur représentant 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 Option facultative.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 Option facultative.Optional. Instruction (s) pour gérer les erreurs qui se produisent dans le bloc de Try associé.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 Option facultative.Optional. Mot clé qui sort de la structure Try...Catch...Finally.Keyword that breaks out of the Try...Catch...Finally structure. L’exécution reprend avec le code qui suit immédiatement l’instruction End Try.Execution resumes with the code immediately following the End Try statement. L’instruction Finally est toujours exécutée.The Finally statement will still be executed. Non autorisé dans les blocs Finally.Not allowed in Finally blocks.
Finally Option facultative.Optional. Un bloc Finally est toujours exécuté lorsque l’exécution quitte une partie de l’instruction Try...Catch.A Finally block is always executed when execution leaves any part of the Try...Catch statement.
finallyStatements Option facultative.Optional. Instruction (s) qui sont exécutées une fois que toutes les autres opérations de traitement des erreurs se sont produites.Statement(s) that are executed after all other error processing has occurred.
End Try Met fin à la structure Try...Catch...Finally.Terminates the Try...Catch...Finally structure.

NotesRemarks

Si vous vous attendez à ce qu’une exception particulière se produise pendant une section de code particulière, placez le code dans un bloc Try et utilisez un bloc Catch pour conserver le contrôle et gérer l’exception, le cas échéant.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.

Une instruction Try…Catch se compose d’un bloc Try suivi d’une ou plusieurs clauses Catch, 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. Quand une exception est levée dans un bloc Try, Visual Basic recherche l’instruction Catch 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 instruction Catch correspondante est introuvable, 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 bloc de Catch n’est trouvé, Visual Basic affiche un message d’exception non gérée à 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 instructions Catch dans une instruction Try…Catch.You can use more than one Catch statement in a Try…Catch statement. Dans ce cas, l’ordre des clauses de Catch est significatif, 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.

Les conditions d’instruction Catch suivantes sont les moins spécifiques et interceptent toutes les exceptions qui dérivent de la classe Exception.The following Catch statement conditions are the least specific, and will catch all exceptions that derive from the Exception class. En général, vous devez utiliser l’une de ces variations comme dernier bloc de Catch dans la structure de Try...Catch...Finally, après avoir intercepté 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. Le workflow de contrôle ne peut jamais atteindre un bloc de Catch qui suit l’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 pas de variable exception, par exemple : CatchThe statement has no exception variable, for example: 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.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 instruction Catch correspondante n’est trouvée, la recherche passe aux instructions Catch du bloc Try…Catch…Finally externe.If no matching Catch statement is found, the search proceeds to the Catch statements of the outer Try…Catch…Finally block.

Les variables locales d’un bloc de Try ne sont pas disponibles dans un bloc Catch, car il s’agit de blocs distincts.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 structure Try...Catch...Finally.If you want to use a variable in more than one block, declare the variable outside the Try...Catch...Finally structure.

Conseil

L’instruction Try…Catch…Finally est disponible sous la forme d’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, Property, etc, puis la gestion des erreurs (exceptions) .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 Code Snippets.For more information, see Code Snippets.

Finally (bloc)Finally block

Si vous avez une ou plusieurs instructions qui doivent s’exécuter avant de quitter la structure Try, utilisez un bloc Finally.If you have one or more statements that must run before you exit the Try structure, use a Finally block. Le contrôle passe au bloc Finally juste avant qu’il ne soit en dehors de la structure Try…Catch.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ù dans la structure Try.This is true even if an exception occurs anywhere inside the Try structure.

Un bloc Finally est utile pour exécuter tout code qui doit s’exécuter même en cas d’exception.A Finally block is useful for running any code that must execute even if there is an exception. Le contrôle est passé au bloc Finally, quelle que soit la façon dont le bloc Try...Catch s’arrête.Control is passed to the Finally block regardless of how the Try...Catch block exits.

Le code d’un bloc Finally s’exécute même si votre code rencontre une instruction Return dans un bloc Try ou Catch.The code in a Finally block runs even if your code encounters a Return statement in a Try or Catch block. Le contrôle ne passe pas d’un bloc Try ou Catch au bloc Finally correspondant 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 possible de transférer explicitement l’exécution dans un bloc Finally.It is not valid to explicitly transfer execution into a Finally block. Le transfert de l’exécution en dehors d’un bloc de Finally n’est pas valide, sauf par le biais d’une exception.Transferring execution out of a Finally block is not valid, except through an exception.

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

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 la suppression des ressources, quelle que soit la façon 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

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

Les propriétés de l’objet Exception permettent d’identifier la cause et l’emplacement d’une exception.The properties of the Exception object help to identify the cause and location of an exception. Par exemple, la propriété StackTrace répertorie les méthodes appelées qui ont conduit à l’exception, ce qui vous permet de 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 décrivant l’exception.Message returns a message that describes the exception. HelpLink retourne un lien vers un fichier d’aide associé.HelpLink returns a link to an associated Help file. InnerException retourne l’objet Exception à l’origine de l’exception actuelle ou retourne Nothing s’il n’y a pas de Exceptiond’origine.InnerException returns the Exception object that caused the current exception, or it returns Nothing if there is no original Exception.

Considérations à prendre en compte lors de l’utilisation d’un bloc try... Catch (instruction)Considerations when using a Try…Catch statement

Utilisez une instruction Try…Catch uniquement pour signaler l’occurrence d’événements de programme inhabituels ou imprévus.Use a Try…Catch statement only to signal the occurrence of unusual or unanticipated program events. Les raisons sont les suivantes :Reasons for this include the following:

  • L’interception des exceptions au moment de l’exécution crée une surcharge supplémentaire et est susceptible d’être plus lente que la 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 bloc de Catch n’est pas géré correctement, l’exception peut ne pas être signalée correctement aux utilisateurs.If a Catch block is not handled correctly, the exception might not be reported correctly to users.

  • La gestion des exceptions rend un programme plus complexe.Exception handling makes a program more complex.

Vous n’avez pas toujours besoin d’une instruction Try…Catch 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 si un fichier existe avant d’essayer de l’ouvrir.The following example checks whether a file exists before trying to open it. Cela réduit le besoin d’intercepter une exception levée par la méthode OpenText.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 des blocs Catch peut signaler correctement les exceptions aux utilisateurs, que ce soit via une journalisation thread-safe ou des 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 peuvent rester inconnues.Otherwise, exceptions might remain unknown.

Méthodes AsyncAsync methods

Si vous marquez une méthode avec le modificateur Async , vous pouvez utiliser l’opérateur await 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 l’opérateur Await interrompt 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 associée à l’opérateur Await se termine, 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 Control flow in Async Programs.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, ce qui indique qu’elle s’est terminée 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 par un état d’annulation, ce qui entraîne la levée d’une OperationCanceledException 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 l’un ou l’autre type d’exception, placez l’expression Await associée à la tâche dans un bloc Try, puis interceptez l’exception dans le bloc Catch.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 étaient responsables de son erreur.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 n’est qu’une des exceptions, et vous ne pouvez pas prédire l’exception qui sera 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.

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

IteratorsIterators

Une fonction d’itérateur ou un accesseur Get 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 instruction yield pour retourner chaque élément de la collection un par un.An iterator uses a Yield statement to return each element of the collection one at a time. Vous appelez une fonction d’itérateur à l’aide d’un pour chaque... Instruction suivante.You call an iterator function by using a For Each...Next Statement.

Une instruction Yield peut se trouver à l’intérieur d’un bloc Try.A Yield statement can be inside a Try block. Un bloc Try qui contient une instruction Yield peut avoir des blocs Catch et peut avoir un bloc Finally.A Try block that contains a Yield statement can have Catch blocks, and can have a Finally block. Pour obtenir un exemple, consultez la section « blocs try dans Visual Basic » d' itérateurs .See the "Try Blocks in Visual Basic" section of Iterators for an example.

Une instruction Yield ne peut pas se trouver à l’intérieur d’un bloc Catch ou d’un bloc Finally.A Yield statement cannot be inside a Catch block or a Finally block.

Si le corps de For Each (en dehors de la fonction d’itérateur) lève une exception, un bloc Catch dans la fonction d’itérateur n’est pas exécuté, mais un bloc Finally 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 bloc de Catch à 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, telles 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, quand vous le placez sur un partage de serveur et que vous exécutez à partir de là, génère l’erreur « System. Security. SecurityException : échec 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 classe SecurityException.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 l’instruction Process.Start dans un Subdistinct.In such a partial-trust situation, you have to put the Process.Start statement in a separate Sub. L’appel initial de l' Sub échoue.The initial call to the Sub will fail. Cela permet à Try...Catch de l’intercepter avant que le Sub contenant Process.Start soit démarré et que l’exception de sécurité soit produite.This enables Try...Catch to catch it before the Sub that contains Process.Start is started and the security exception produced.

ExemplesExamples

Structure de try... Catch... SuivieThe structure of Try...Catch...Finally

L’exemple suivant illustre la structure de l’instruction Try...Catch...Finally.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, la méthode CreateException lève une NullReferenceException.In the following example, the CreateException method throws a NullReferenceException. Le code qui génère l’exception n’est pas dans un bloc Try.The code that generates the exception is not in a Try block. Par conséquent, la méthode CreateException ne gère pas l’exception.Therefore, the CreateException method does not handle the exception. La méthode RunSample gère l’exception, car l’appel à la méthode CreateException se trouve dans un bloc Try.The RunSample method does handle the exception because the call to the CreateException method is in a Try block.

L’exemple comprend des instructions Catch pour plusieurs types d’exceptions, classées du 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

Instruction catch whenThe Catch When statement

L’exemple suivant montre comment utiliser une instruction Catch When 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 du bloc Catch 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 contient une instruction Try…Catch qui est contenue dans un bloc Try.The following example has a Try…Catch statement that is contained in a Try block. Le bloc Catch interne lève une exception dont la propriété InnerException a la valeur de l’exception d’origine.The inner Catch block throws an exception that has its InnerException property set to the original exception. Le bloc de Catch externe 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, l’expression Await se trouve dans un bloc Try de l’appelant, et l’exception est interceptée dans le bloc Catch.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 bloc Catch, la propriété IsFaulted de la tâche a la valeur Trueet la propriété Exception.InnerException de la tâche a la valeur de 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 bloc Catch et la propriété IsCanceled de la tâche a la valeur True.The exception is caught in the Catch block, and the task's IsCanceled property is set to True. Toutefois, dans certaines conditions qui ne s’appliquent pas à cet exemple, IsFaulted est défini sur 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 de plusieurs exceptions 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 bloc de Try a l’expression Await pour la tâche qui Task.WhenAll retournée.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 auxquelles 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 bloc Catch itère au sein des exceptions, qui se trouvent dans la propriété Exception.InnerExceptions de la tâche que Task.WhenAll retournée.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