Wie kann ich warten, bis die asynchrone Methode abgeschlossen ist?

Ich schreibe eine WinForms-Anwendung, die Daten auf ein Gerät der USB-HID-Klasse überträgt. Meine Anwendung verwendet die hervorragende generische HID-Bibliothek v6.0, die hier zu finden ist . Kurz gesagt, wenn ich Daten auf das Gerät schreiben muss, wird folgender Code aufgerufen:

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();
    }
}

Wenn mein Code aus der while-Schleife herausfällt, muss ich einige Daten vom Gerät lesen. Das Gerät kann jedoch nicht sofort antworten, daher muss ich warten, bis dieser Anruf zurückkommt, bevor ich fortfahre. RequestToGetInputReport () wird wie folgt deklariert:

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

Für das, was es wert ist, sieht die Deklaration für GetInputReportViaInterruptTransfer () folgendermaßen aus:

internal async Task<int> GetInputReportViaInterruptTransfer()

Leider bin ich mit der Funktionsweise der neuen Async / Wait-Technologien in .NET 4.5 nicht sehr vertraut. Ich habe vorhin ein wenig über das Schlüsselwort await gelesen und dadurch den Eindruck erweckt, dass der Aufruf von GetInputReportViaInterruptTransfer () in RequestToGetInputReport () warten würde (und vielleicht auch?), Aber es scheint nicht so, als würde RequestToGetInputReport () aufgerufen selbst wartet, weil ich fast sofort wieder in die while-Schleife eintrete?

Kann jemand das Verhalten klären, das ich sehe?

Vermeiden Sie async void. Lassen Sie Ihre Methoden Taskstatt zurückgeben void. Dann kannst du awaitsie.

So was:

private async Task 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
        await RequestToGetInputReport();
    }
}

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

Die wichtigste Sache zu wissen asyncund awaitist , dass await nicht der Fall ist für den damit verbundenen Aufruf vollständig zu warten. Sie awaitmüssen das Ergebnis der Operation sofort und synchron zurückgeben, wenn die Operation bereits abgeschlossen ist, oder, falls dies nicht der Fall ist, eine Fortsetzung planen, um den Rest der asyncMethode auszuführen , und dann die Steuerung an den Aufrufer zurückgeben. Wenn der asynchrone Vorgang abgeschlossen ist, wird der geplante Abschluss ausgeführt.

Die Antwort auf die spezifische Frage im Titel Ihrer Frage besteht darin async, den Rückgabewert einer Methode (der vom Typ Taskoder sein sollte Task<T>) durch Aufrufen einer geeigneten WaitMethode zu blockieren :

public static async Task<Foo> GetFooAsync()
{
    // Start asynchronous operation(s) and return associated task.
    ...
}

public static Foo CallGetFooAsyncAndWaitOnResult()
{
    var task = GetFooAsync();
    task.Wait(); // Blocks current thread until GetFooAsync task completes
                 // For pedagogical use only: in general, don't do this!
    var result = task.Result;
    return result;
}

In diesem Code-Snippet CallGetFooAsyncAndWaitOnResulthandelt es sich um einen synchronen Wrapper um eine asynchrone Methode GetFooAsync. Dieses Muster ist jedoch größtenteils zu vermeiden, da es einen gesamten Thread-Pool-Thread für die Dauer der asynchronen Operation blockiert. Dies ist eine ineffiziente Verwendung der verschiedenen asynchronen Mechanismen, die von APIs bereitgestellt werden, die große Anstrengungen unternehmen, um sie bereitzustellen.

Die Antwort unter "Warten" wartet nicht auf den Abschluss des Anrufs. Sie enthält mehrere detailliertere Erklärungen zu diesen Schlüsselwörtern.

In der Zwischenzeit async voidhält @Stephen Clearys Anleitung zu . Weitere nette Erklärungen dafür finden Sie unter http://www.tonicodes.net/blog/why-you-should-almost-never-write-void-asynchronous-methods/ und https://jaylee.org/archive/ 2012/07/08 / c-scharf-asynchrone-Tipps-und-Tricks-Teil-2-asynchrone-void.html

Die beste Lösung, um AsynMethod zu warten, bis die Aufgabe abgeschlossen ist, ist

var result = Task.Run(async() => await yourAsyncMethod()).Result;

Hier ist eine Problemumgehung mit einem Flag:

//outside your event or method, but inside your class
private bool IsExecuted = false;

private async Task MethodA()
{

//Do Stuff Here

IsExecuted = true;
}

.
.
.

//Inside your event or method

{
await MethodA();

while (!isExecuted) Thread.Sleep(200); // <-------

await MethodB();
}

Setzen Sie einfach Wait (), um zu warten, bis die Aufgabe abgeschlossen ist

GetInputReportViaInterruptTransfer().Wait();

Eigentlich fand ich dies hilfreicher für Funktionen, die IAsyncAction zurückgeben.

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

Das folgende Snippet zeigt eine Möglichkeit, um sicherzustellen, dass die erwartete Methode abgeschlossen ist, bevor Sie zum Aufrufer zurückkehren. Ich würde jedoch nicht sagen, dass es eine gute Praxis ist. Bitte bearbeiten Sie meine Antwort mit Erklärungen, wenn Sie anders denken.

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

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