Comment attendre la fin d'une méthode asynchrone ?

Question

J'écris une application WinForms qui transfère des données vers un périphérique de classe USB HID. Mon application utilise l'excellente bibliothèque Generic HID v6.0 qui se trouve à l'adresse suivante aquí . En bref, lorsque j'ai besoin d'écrire des données sur le périphérique, c'est le code qui est appelé :

private async void RequestToSendOutputReport(List<byte[]> byteArrays)
{
    foreach (byte[] b in byteArrays)
    {
        while (condition)
        {
            // we'll typically execute this code many times until the condition is no longer met
            Task t = SendOutputReportViaInterruptTransfer();
            await t;
        }

        // read some data from device; we need to wait for this to return
        RequestToGetInputReport();
    }
}

Lorsque mon code sort de la boucle while, je dois lire des données à partir du dispositif. Cependant, l'appareil n'est pas en mesure de répondre immédiatement et je dois donc attendre le retour de cet appel avant de poursuivre. Tel qu'il existe actuellement, RequestToGetInputReport() est déclaré comme suit :

private async void RequestToGetInputReport()
{
    // lots of code prior to this
    int bytesRead = await GetInputReportViaInterruptTransfer();
}

Pour ce que cela vaut, la déclaration pour GetInputReportViaInterruptTransfer() ressemble à ceci :

internal async Task<int> GetInputReportViaInterruptTransfer()

Malheureusement, je ne suis pas très familier avec le fonctionnement des nouvelles technologies async/await de .NET 4.5. J'ai lu un peu plus tôt le mot-clé await et cela m'a donné l'impression que l'appel à GetInputReportViaInterruptTransfer() à l'intérieur de RequestToGetInputReport() attendrait (et c'est peut-être le cas ?) mais il ne semble pas que l'appel à RequestToGetInputReport() lui-même attende car il semble que je rentre dans la boucle while presque immédiatement ?

Quelqu'un peut-il clarifier le comportement que je constate ?

Answer 1

L'extrait suivant montre une façon de s'assurer que la méthode attendue se termine avant de retourner à l'appelant. CEPENDANT, je ne dirais pas que c'est une bonne pratique. Veuillez modifier ma réponse avec des explications si vous pensez le contraire.

public async Task AnAsyncMethodThatCompletes()
{
    await SomeAsyncMethod();
    DoSomeMoreStuff();
    await Task.Factory.StartNew(() => { }); // <-- This line here, at the end
}

await AnAsyncMethodThatCompletes();
Console.WriteLine("AnAsyncMethodThatCompletes() completed.")

Answer 2

En fait, j'ai trouvé cela plus utile pour les fonctions qui renvoient IAsyncAction.

            var task = asyncFunction();
            while (task.Status == AsyncStatus.Completed) ;