Programmation asynchrone avec Async et Await (C# et Visual Basic)

Vous pouvez éviter des goulots d'étranglement au niveau de les performances et améliorer la réactivité globale de votre application à l'aide de la programmation asynchrone.Toutefois, les techniques traditionnelles pour écrire des applications asynchrones peuvent être complexes, les rendant difficile à écrire, déboguer, et mettre à jour.

Visual Studio 2012 présente une approche simplifiée, l'async programmation, qui tire parti de la prise en charge asynchrone dans .NET Framework 4.5 et Windows Runtime.Le compilateur effectue un travail difficile que le développeur utilisé pour faire, et votre application conserve une structure logique qui ressemble au code synchrone.Par conséquent, vous obtenez tous les avantages de la programmation asynchrone avec une fraction d'effort.

Cette rubrique comprend les sections suivantes.

• Async améliore la réactivité
• Il est plus facile écrire des méthodes Async
• Ce qui se produit dans une méthode Async
• Méthodes Async d'API
• Threads
• Async et attendent
• Paramètres et type de retour
• Convention d'affectation de noms
• Rubriques connexes
• Exemple complet
• Rubriques connexes

Cette rubrique fournit une vue d'ensemble de quand et comment utiliser l'async programmation et inclut des liens pour prendre en charge les rubriques qui contiennent des informations et des exemples.

Async améliore la réactivité

Asynchrony est essentielle pour les activités qui sont non bloquantes, par exemple lorsque votre application accède au Web.Accès à une ressource web est parfois lente ou différée.Si cette activité est bloquée dans un processus synchrone, l'application entière doit attendre.Dans un processus asynchrone, l'application peut continuer d'autres tâches qui ne dépend pas de la ressource web jusqu'à ce que la tâche non bloquante complète.

Le tableau suivant présente les zones courantes où la programmation asynchrone améliore la réactivité.Les API répertoriées d' .NET Framework 4.5 et l' Windows Runtime contiennent des méthodes qui prennent en charge la programmation async.

Asynchrony affiche particulièrement utiles pour les applications qui accèdent au thread d'interface utilisateur car toute activité liée à l'interface utilisateur partage généralement un thread.Si un processus est bloqué dans une application synchrone, tous sont bloqués.Votre application cesse de répondre, et vous pouvez conclure qu'elle a échoué lors à la place attend simplement.

Lorsque vous utilisez des méthodes asynchrones, l'application continue de répondre à l'interface utilisateur.Vous pouvez redimensionner ou réduire une fenêtre, par exemple, vous pouvez fermer l'application si vous ne souhaitez pas l'attente se termine.

L'approche basée async- ajoute l'équivalent d'une communication automatique à la liste d'options dont vous pouvez choisir lors de la conception des opérations asynchrones.Autrement dit, vous obtenez tous les avantages de la programmation asynchrone traditionnelles mais avec beaucoup moins d'efforts du développeur.

Il est plus facile écrire des méthodes Async

Les mots clés d' Async et d' Attendez en Visual Basic et les mots clés d' async et d' attendez en c sont le cœur de programmation async.À l'aide de ces deux mots clés, vous pouvez utiliser des ressources dans le.NET Framework ou Windows Runtime pour créer une méthode asynchrone presque aussi facilement que vous créez une méthode synchrone.Les méthodes asynchrones que vous définissez à l'aide de l'async et attendez est appelé des méthodes async.

L'exemple suivant illustre une méthode async.Presque tous dans le code doit ressembler complètement familier à vous.Les commentaires requièrent les fonctionnalités que vous ajoutez pour créer l'asynchrony.

Vous pouvez rechercher le fichier d'exemple complet à la fin de cette rubrique, et vous pouvez télécharger l'exemple provenant de Exemple Async : L'exemple « de la programmation asynchrone avec Async et attendent ».

' Three things to note in the signature:
'  - The method has an Async modifier. 
'  - The return type is Task or Task(Of T). (See "Return Types" section.)
'    Here, it is Task(Of Integer) because the return statement returns an integer.
'  - The method name ends in "Async."
Async Function AccessTheWebAsync() As Task(Of Integer)

    ' You need to add a reference to System.Net.Http to declare client.
    Dim client As HttpClient = New HttpClient()

    ' GetStringAsync returns a Task(Of String). That means that when you await the
    ' task you'll get a string (urlContents).
    Dim getStringTask As Task(Of String) = client.GetStringAsync("https://msdn.microsoft.com")


    ' You can do work here that doesn't rely on the string from GetStringAsync.
    DoIndependentWork()

    ' The Await operator suspends AccessTheWebAsync.
    '  - AccessTheWebAsync can't continue until getStringTask is complete.
    '  - Meanwhile, control returns to the caller of AccessTheWebAsync.
    '  - Control resumes here when getStringTask is complete. 
    '  - The Await operator then retrieves the string result from getStringTask.
    Dim urlContents As String = Await getStringTask

    ' The return statement specifies an integer result.
    ' Any methods that are awaiting AccessTheWebAsync retrieve the length value.
    Return urlContents.Length
End Function

// Three things to note in the signature:
//  - The method has an async modifier. 
//  - The return type is Task or Task<T>. (See "Return Types" section.)
//    Here, it is Task<int> because the return statement returns an integer.
//  - The method name ends in "Async."
async Task<int> AccessTheWebAsync()
{ 
    // You need to add a reference to System.Net.Http to declare client.
    HttpClient client = new HttpClient();

    // GetStringAsync returns a Task<string>. That means that when you await the
    // task you'll get a string (urlContents).
    Task<string> getStringTask = client.GetStringAsync("https://msdn.microsoft.com");

    // You can do work here that doesn't rely on the string from GetStringAsync.
    DoIndependentWork();

    // The await operator suspends AccessTheWebAsync.
    //  - AccessTheWebAsync can't continue until getStringTask is complete.
    //  - Meanwhile, control returns to the caller of AccessTheWebAsync.
    //  - Control resumes here when getStringTask is complete. 
    //  - The await operator then retrieves the string result from getStringTask.
    string urlContents = await getStringTask;

    // The return statement specifies an integer result.
    // Any methods that are awaiting AccessTheWebAsync retrieve the length value.
    return urlContents.Length;
}

Si AccessTheWebAsync n'a aucun travail qu'il peut exécuter d'appeler GetStringAsync et attendre son achèvement, vous pouvez simplifier votre code en appelant et l'attente dans l'instruction unique suivante.

Dim urlContents As String = Await client.GetStringAsync()

string urlContents = await client.GetStringAsync();

Les caractéristiques suivantes résument ce qui fait à l'exemple précédent une méthode async.

• La signature de méthode inclut un modificateur d' Async ou d' async .

• Le nom d'une méthode async, par convention, termine avec un suffixe « Async ».

• Le type de retour est l'un des types suivants :

  • Task<TResult> si votre méthode a une instruction return dans lequel l'opérande a le type TResult.

  • Task si votre méthode n'a aucune instruction return ou une instruction return sans l'opérande.

  • Void ( Sub en Visual Basic) si vous écrivez un gestionnaire d'événements async.

  Pour plus d'informations, consultez « types de retour et les paramètres » plus loin dans cette rubrique.

• La méthode inclut généralement au moins un attendent l'expression, qui marque un point où la méthode ne peut pas continuer tant que l'opération asynchrone attendue terminée.Dans le même temps, la méthode est interrompue, et retourne à l'appelant de la méthode.La section suivante de cette rubrique illustre ce qui se produit au point de sélection.

Dans les méthodes async, vous utilisez les mots clés et les types fournis pour indiquer que vous souhaitez faire, et le compilateur effectue le reste, notamment contenir ce qui doit se produire lorsque le contrôle retourne à un point d'attente dans une méthode interrompue.Il peut être difficile de gérer des processus de routine, tels que les boucles et la gestion des exceptions, dans le code asynchrone traditionnel.Dans une méthode async, vous écrivez ces éléments comme vous l'auriez fais dans une solution synchrone, et le problème est résolu.

Pour plus d'informations sur asynchrony dans les versions antérieures du .NET Framework, consultez Bibliothèque parallèle de tâches et programmation asynchrone .NET traditionnelle.

Ce qui se produit dans une méthode Async

La manière la plus importante à comprendre dans la programmation asynchrone est comment le flux de contrôle se déplace de la méthode à la méthode.Le diagramme suivant vous conduit au cours de le processus.

Les numéros dans le diagramme correspondent aux étapes suivantes.

1. Les appels du gestionnaire d'événements et attendre la méthode async d' AccessTheWebAsync .

2. AccessTheWebAsync crée une instance d' HttpClient et appelle la méthode asynchrone d' GetStringAsync pour télécharger le contenu d'un site Web en tant que chaîne.

3. Tout ce qui se produit dans GetStringAsync qui interrompt la progression.Peut-être elle doit attendre un site Web pour la télécharger ou une autre activité de blocage.Pour éviter de bloquer des ressources, contrôle de rendements d' GetStringAsync à son appelant, AccessTheWebAsync.

   GetStringAsync retourne Task<TResult> où TResult est une chaîne, et AccessTheWebAsync assigne la tâche à la variable d' getStringTask .La tâche représente le processus actuel de l'appel à GetStringAsync, avec un engagement pour produire une valeur de chaîne réelle lorsque le travail est terminé.

4. Étant donné qu' getStringTask n'a pas encore été attendu, AccessTheWebAsync peut continuer d'autres tâches qui ne dépend pas du résultat final d' GetStringAsync.Cette opération est représenté par un appel à la méthode synchrone DoIndependentWork.

5. DoIndependentWork est une méthode synchrone qui effectue son travail et retourne à son appelant.

6. AccessTheWebAsync a échoué de travail qu'il peut exécuter sans résultat d' getStringTask.AccessTheWebAsync ensuite souhaite calculer et retourner la longueur de la chaîne téléchargée, mais la méthode ne peut pas calculer cette valeur jusqu'à ce que la méthode a la chaîne.

   Par conséquent, AccessTheWebAsync utilise un opérateur d'attente pour interrompre sa progression et de céder le contrôle à la méthode qui a appelé AccessTheWebAsync.AccessTheWebAsync retourne Task(Of Integer) ou Task<int> à l'appelant.La tâche représente une promesse de produire un résultat entier qui est la longueur de la chaîne téléchargée.

   [!REMARQUE]

   Si GetStringAsync (et par conséquent getStringTask) est terminé avant qu' AccessTheWebAsync déclenchement unique l', le contrôle reste dans AccessTheWebAsync.Les dépenses de s'interrompre puis de retourner à AccessTheWebAsync seraient gaspillées si le processus asynchrone appelée (getStringTask) se sont déjà effectuées et AccessTheWebSync ne doit pas attendre le résultat final.

   À l'intérieur de l'appel (le gestionnaire d'événements dans cet exemple), le processus se répète.L'appelant peut effectuer d'autres tâches qui ne dépend pas du résultat d' AccessTheWebAsync avant d'attente ce résultat, ou l'appelant peut attendre immédiatement.Lorsque le gestionnaire d'événements atteint une expression d'attente, l'application se concentre sur l'achèvement d' GetStringAsync.Le gestionnaire d'événements attend AccessTheWebAsync, et AccessTheWebAsync attend GetStringAsync.

7. GetStringAsync se termine et produit un résultat de chaîne.Le résultat de chaîne n'est pas retourné par l'appel à GetStringAsync de la manière dont vous pouvez vous attendre.N'oubliez pas que la méthode est retournée déjà une tâche à l'étape 3.) à la place, le résultat de chaîne est stocké dans la tâche qui représente l'achèvement de la méthode, getStringTask.L'opérateur d'attente récupère le résultat d' getStringTask.L'instruction d'assignation assigne le résultat extrait à urlContents.

8. Lorsque AccessTheWebAsync a le résultat de chaîne, la méthode peut calculer la longueur de la chaîne.Le travail d' AccessTheWebAsync est également complet, et le gestionnaire d'événements en attente peut continuer.Dans l'exemple complet à la fin de la rubrique, vous pouvez vérifier que le gestionnaire d'événements récupère et imprime la valeur du résultat de longueur.

Si vous débutez à la programmation asynchrone, prenez une minute à prendre en considération la différence entre le comportement synchrone et asynchrone.Une méthode synchrone retourne lorsque son travail est terminé (étape 5), mais une méthode async retourne une valeur de tâche lorsque son travail est suspendu (étapes 3 et 6).Lorsque la méthode async termine par la suite sa tâche, la tâche est marquée comme terminée et le résultat, le cas échéant, est stocké dans la tâche.

Pour plus d'informations sur le flux de contrôle, consultez Flux de contrôle dans les programmes Async (C# et Visual Basic).

Méthodes Async d'API

Vous pouvez vous demander où rechercher les méthodes telles que GetStringAsync qui prennent en charge la programmation async.Le .NET Framework 4.5 contient plusieurs membres qui utilisent l'async et attendent.Vous pouvez identifier ces membres par le suffixe « Async » joint au nom de membre et un type de retour Task ou Task<TResult>.Par exemple, la classe System.IO.Stream contient des méthodes telles que CopyToAsync, ReadAsync, et WriteAsync à côté des méthodes synchrones CopyTo, Read, et Write.

Windows Runtime contient également de nombreuses méthodes que vous pouvez utiliser avec l'async et attendre dans les applications d' Windows Store .Pour plus de méthodes d'informations et d'exemples, consultez Démarrage rapide : à l'aide de l'opérateur d'attente pour la programmation asynchroneProgrammation asynchrone (applications de mémoire windows), et WhenAny : combler l'écart entre .NET Framework et Windows Runtime (C# et Visual Basic).

Threads

Les méthodes Async sont conçues pour être des opérations non bloquantes.Une expression d'attente dans une méthode async ne bloque pas le thread actuel pendant que la tâche attendue exécute.Au lieu de cela, l'expression inscrit le reste de la méthode comme continuation et contrôle de retour à l'appelant de la méthode async.

L'async et attendent des mots clés ne provoquent pas les threads supplémentaires d'être créés.Les méthodes Async ne requièrent pas de multithreading car une méthode async ne fonctionne pas sur son propre thread.La méthode s'éxécute sur le contexte de synchronisation courant et utilise du temps sur le thread uniquement quand la méthode est active.Vous pouvez utiliser Task.Run au processeur travail lié à passer à un thread d'arrière-plan, mais un thread d'arrière-plan ne permet pas à un processus qui attend simplement les résultats soit disponible.

L'approche async- basée sur la programmation asynchrone est préférable à exister des approches dans presque chaque cas.En particulier, cette approche est préférable à BackgroundWorker pour les opérations E/S- connexes car le code est plus simple et vous n'avez pas à se protéger contre des conditions de concurrence critique.En combinaison avec Task.Run, la programmation async est préférable à BackgroundWorker pour les opérations utilisant le processeur de manière intensive car la programmation async sépare les détails de coordination d'exécuter votre code de travail qu' Task.Run transfère le threadpool.

Async et attendent

Si vous spécifiez qu'une méthode est une méthode async à l'aide d'un modificateur d' Async ou d' async, vous activez les deux fonctions suivantes.

• La méthode marquée async peut utiliser Attendez ou attendez pour indiquer les points de suspension.L'opérateur d'attente indique au compilateur que la méthode async ne peut pas continuer le passé qui pointent jusqu'à ce que le processus asynchrone attendu terminé.Dans le même temps, le contrôle retourne à l'appelant de la méthode async.

  La sélection d'une méthode async à une expression d'attente ne constitue pas une sortie de la méthode, et les blocs d' finally ne fonctionnent pas.

• La méthode marquée async elle-même peut être attendue par les méthodes qui l'appelle.

Une méthode async contient généralement un ou plusieurs occurrences d'un opérateur d'attente, mais l'absence de attendent des expressions ne provoque pas d'erreur du compilateur.Si une méthode async n'utilise pas un opérateur d'attente pour marquer un point de sélection, la méthode exécute comme le fait une méthode synchrone, en dépit de le modificateur async.Le compilateur publiera un avertissement pour un tel code.

Async, async, Await, et await sont des mots clés contextuels.Pour plus d'informations et des exemples, consultez les rubriques suivantes :

• Async (Visual Basic)

• async (référence C#)

• Await, opérateur (Visual Basic)

• await (Référence C#)

Paramètres et type de retour

Dans la programmation.NET Framework, une méthode async retourne généralement Task ou Task<TResult>.Dans une méthode async, un opérateur d'attente est appliqué à une tâche qui est retournée à partir d'un appel à une autre méthode async.

Vous spécifiez Task<TResult> comme type de retour si la méthode contient une instruction retour (Visual Basic) ou retour (C#) qui spécifie un opérande de type TResult.

Vous utilisez Task comme type de retour si la méthode n'a aucune instruction return ou une instruction return qui ne retourne pas un opérande.

L'exemple suivant montre comment vous déclarez et appeler une méthode qui retourne Task<TResult> ou Task.

' Signature specifies Task(Of Integer)
Async Function TaskOfTResult_MethodAsync() As Task(Of Integer)

    Dim hours As Integer
    ' . . .
    ' Return statement specifies an integer result.
    Return hours
End Function

' Calls to TaskOfTResult_MethodAsync
Dim returnedTaskTResult As Task(Of Integer) = TaskOfTResult_MethodAsync()
Dim intResult As Integer = Await returnedTaskTResult
' or, in a single statement
Dim intResult As Integer = Await TaskOfTResult_MethodAsync()


' Signature specifies Task
Async Function Task_MethodAsync() As Task

    ' . . .
    ' The method has no return statement.
End Function

' Calls to Task_MethodAsync
Task returnedTask = Task_MethodAsync()
Await returnedTask
' or, in a single statement
Await Task_MethodAsync()

// Signature specifies Task<TResult>
async Task<int> TaskOfTResult_MethodAsync()
{
    int hours;
    // . . .
    // Return statement specifies an integer result.
    return hours;
}

// Calls to TaskOfTResult_MethodAsync
Task<int> returnedTaskTResult = TaskOfTResult_MethodAsync();
int intResult = await returnedTaskTResult;
// or, in a single statement
int intResult = await TaskOfTResult_MethodAsync();


// Signature specifies Task
async Task Task_MethodAsync()
{
    // . . .
    // The method has no return statement.  
}

// Calls to Task_MethodAsync
Task returnedTask = Task_MethodAsync();
await returnedTask;
// or, in a single statement
await Task_MethodAsync();

Chaque tâche retournée représente le travail actif.Une tâche encapsule des informations sur l'état du processus asynchrone et, par la suite, le résultat final du processus ou l'exception qui déclenche de processus si elle n'aboutit pas.

Une méthode async peut également être une méthode d' Sub (Visual Basic) ou avoir un type de retour d' void (c).Ce type de retour est utilisé principalement pour définir des gestionnaires d'événements, où un type de retour d' void est requis.Les gestionnaires d'événements Async utilisent souvent de point de départ aux programmes async.

Une méthode async qui est une procédure Sub ou dont le type de retour est void ne peut pas être attendue, et l'appellant d'une méthode void ne peut pas catcher aucune exception lancée par la méthode.

Une méthode async ne peut pas déclarer des paramètres ByRef dans Visual Basic ou référence ou out en C#, mais la méthode peut appeler les méthodes qui ont ces paramètres.

Pour plus d'informations et d'exemples, consultez Types de retour Async (C# et Visual Basic).Pour plus d'informations sur l'interception des exceptions dans les méthodes async, consultez try-catch (référence C#) ou Try...Catch...Finally, instruction (Visual Basic).

Les API asynchrones dans la programmation d' Windows Runtime ont un des types de retour suivants, qui sont semblables aux tâches :

• IAsyncOperation, qui correspond à Task<TResult>

• IAsyncAction, qui correspond à Task

• IAsyncActionWithProgress

• IAsyncOperationWithProgress

Pour plus d'informations et un exemple, consultez Démarrage rapide : à l'aide de l'opérateur d'attente pour la programmation asynchrone.

Convention d'affectation de noms

Par convention, vous ajoutez « Async » aux noms des méthodes qui possèdent un modificateur d' Async ou d' async .

Vous pouvez ignorer la convention où un événement, une classe de base, ou un contrat d'interface suggère un nom différent.Par exemple, vous ne devez pas renommer les gestionnaires d'événements communs, tels que Button1_Click.

Rubriques connexes

Exemple complet

Le code suivant est le fichier de MainWindow.xaml.vb ou MainWindow.xaml.cs de l'application Windows Presentation Foundation (WPF) que cette rubrique traite.Vous pouvez télécharger l'exemple provenant de Exemple Async : L'exemple « de la programmation asynchrone avec Async et attendent ».

' Add an Imports statement and a reference for System.Net.Http
Imports System.Net.Http

Class MainWindow

    ' Mark the event handler with async so you can use Await in it.
    Private Async Sub StartButton_Click(sender As Object, e As RoutedEventArgs)

        ' Call and await separately.
        'Task<int> getLengthTask = AccessTheWebAsync();
        '' You can do independent work here.
        'int contentLength = await getLengthTask;

        Dim contentLength As Integer = Await AccessTheWebAsync()

        ResultsTextBox.Text &=
            String.Format(vbCrLf & "Length of the downloaded string: {0}." & vbCrLf, contentLength)
    End Sub


    ' Three things to note in the signature:
    '  - The method has an Async modifier. 
    '  - The return type is Task or Task(Of T). (See "Return Types" section.)
    '    Here, it is Task(Of Integer) because the return statement returns an integer.
    '  - The method name ends in "Async."
    Async Function AccessTheWebAsync() As Task(Of Integer)

        ' You need to add a reference to System.Net.Http to declare client.
        Dim client As HttpClient = New HttpClient()

        ' GetStringAsync returns a Task(Of String). That means that when you await the
        ' task you'll get a string (urlContents).
        Dim getStringTask As Task(Of String) = client.GetStringAsync("https://msdn.microsoft.com")


        ' You can do work here that doesn't rely on the string from GetStringAsync.
        DoIndependentWork()

        ' The Await operator suspends AccessTheWebAsync.
        '  - AccessTheWebAsync can't continue until getStringTask is complete.
        '  - Meanwhile, control returns to the caller of AccessTheWebAsync.
        '  - Control resumes here when getStringTask is complete. 
        '  - The Await operator then retrieves the string result from getStringTask.
        Dim urlContents As String = Await getStringTask

        ' The return statement specifies an integer result.
        ' Any methods that are awaiting AccessTheWebAsync retrieve the length value.
        Return urlContents.Length
    End Function


    Sub DoIndependentWork()
        ResultsTextBox.Text &= "Working . . . . . . ." & vbCrLf
    End Sub
End Class

' Sample Output:

' Working . . . . . . .

' Length of the downloaded string: 41763.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

// Add a using directive and a reference for System.Net.Http;
using System.Net.Http;

namespace AsyncFirstExample
{
    public partial class MainWindow : Window
    {
        // Mark the event handler with async so you can use await in it.
        private async void StartButton_Click(object sender, RoutedEventArgs e)
        {
            // Call and await separately.
            //Task<int> getLengthTask = AccessTheWebAsync();
            //// You can do independent work here.
            //int contentLength = await getLengthTask;

            int contentLength = await AccessTheWebAsync();

            resultsTextBox.Text +=
                String.Format("\r\nLength of the downloaded string: {0}.\r\n", contentLength);
        }


        // Three things to note in the signature:
        //  - The method has an async modifier. 
        //  - The return type is Task or Task<T>. (See "Return Types" section.)
        //    Here, it is Task<int> because the return statement returns an integer.
        //  - The method name ends in "Async."
        async Task<int> AccessTheWebAsync()
        { 
            // You need to add a reference to System.Net.Http to declare client.
            HttpClient client = new HttpClient();

            // GetStringAsync returns a Task<string>. That means that when you await the
            // task you'll get a string (urlContents).
            Task<string> getStringTask = client.GetStringAsync("https://msdn.microsoft.com");

            // You can do work here that doesn't rely on the string from GetStringAsync.
            DoIndependentWork();

            // The await operator suspends AccessTheWebAsync.
            //  - AccessTheWebAsync can't continue until getStringTask is complete.
            //  - Meanwhile, control returns to the caller of AccessTheWebAsync.
            //  - Control resumes here when getStringTask is complete. 
            //  - The await operator then retrieves the string result from getStringTask.
            string urlContents = await getStringTask;

            // The return statement specifies an integer result.
            // Any methods that are awaiting AccessTheWebAsync retrieve the length value.
            return urlContents.Length;
        }


        void DoIndependentWork()
        {
            resultsTextBox.Text += "Working . . . . . . .\r\n";
        }
    }
}

// Sample Output:

// Working . . . . . . .

// Length of the downloaded string: 41564.

Voir aussi

Référence

async (référence C#)

await (Référence C#)

Await, opérateur (Visual Basic)

Async (Visual Basic)