Come attendere il completamento del metodo asincrono?

Sto scrivendo un'applicazione WinForms che trasferisce i dati su un dispositivo di classe USB HID. La mia applicazione utilizza l'eccellente libreria Generic HID v6.0 che può essere trovata qui . In breve, quando devo scrivere i dati sul dispositivo, questo è il codice che viene chiamato:

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

Quando il mio codice esce dal ciclo while, devo leggere alcuni dati dal dispositivo. Tuttavia, il dispositivo non è in grado di rispondere immediatamente, quindi devo attendere che questa chiamata torni prima di continuare. Come attualmente esiste, RequestToGetInputReport () è dichiarato in questo modo:

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

Per quello che vale, la dichiarazione per GetInputReportViaInterruptTransfer () è simile al seguente:

internal async Task<int> GetInputReportViaInterruptTransfer()

Sfortunatamente, non ho molta familiarità con il funzionamento delle nuove tecnologie asincrone / wait in .NET 4.5. Ho letto un po 'prima la parola chiave wait e mi ha dato l'impressione che la chiamata a GetInputReportViaInterruptTransfer () all'interno di RequestToGetInputReport () avrebbe atteso (e forse lo fa?) Ma non sembra la chiamata a RequestToGetInputReport () stesso sta aspettando perché mi sembra di rientrare nel ciclo while quasi immediatamente?

Qualcuno può chiarire il comportamento che sto vedendo?

Evitare async void. Chiedi ai tuoi metodi di restituire Taskinvece di void. Allora puoi awaitloro.

Come questo:

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

La cosa più importante da sapere asynced awaitè che await non attende il completamento della chiamata associata. Ciò che awaitfa è restituire immediatamente e in modo sincrono il risultato dell'operazione se l'operazione è già stata completata o, in caso contrario, pianificare una continuazione per eseguire il resto del asyncmetodo e quindi restituire il controllo al chiamante. Al termine dell'operazione asincrona, verrà eseguito il completamento pianificato.

La risposta alla domanda specifica nel titolo della domanda è bloccare il asyncvalore restituito di un metodo (che dovrebbe essere di tipo Tasko Task<T>) chiamando un Waitmetodo appropriato :

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 questo frammento di codice, CallGetFooAsyncAndWaitOnResultè un wrapper sincrono attorno al metodo asincrono GetFooAsync. Tuttavia, questo modello deve essere evitato per la maggior parte poiché bloccherà un intero thread di pool di thread per la durata dell'operazione asincrona. Questo è un uso inefficiente dei vari meccanismi asincroni esposti dalle API che fanno grandi sforzi per fornirli.

La risposta in "wait" non attende il completamento della chiamata ha diverse, più dettagliate, spiegazioni di queste parole chiave.

Nel frattempo, la guida di @Stephen Cleary sulle prese async void. Altre belle spiegazioni del perché possono essere trovate su http://www.tonicodes.net/blog/why-you-should-almost-never-write-void-asynchronous-methods/ e https://jaylee.org/archive/ 2012/07/08 / do diesis-asincrone-tips-and-tricks-parte-2-async-void.html

La soluzione migliore per attendere AsynMethod fino al completamento dell'attività è

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

Ecco una soluzione alternativa usando una bandiera:

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

basta mettere Wait () per attendere fino al completamento dell'attività

GetInputReportViaInterruptTransfer().Wait();

Il frammento seguente mostra un modo per assicurarsi che il metodo atteso venga completato prima di tornare al chiamante. TUTTAVIA, non direi che è una buona pratica. Modifica la mia risposta con spiegazioni se la pensi diversamente.

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

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

In realtà l'ho trovato più utile per le funzioni che restituiscono IAsyncAction.

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