Como aguardar a conclusão do método assíncrono?

Estou escrevendo um aplicativo WinForms que transfere dados para um dispositivo de classe USB HID. Meu aplicativo usa a excelente biblioteca HID genérica v6.0, que pode ser encontrada aqui . Em poucas palavras, quando preciso gravar dados no dispositivo, este é o código que é chamado:

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 meu código sai do loop while, preciso ler alguns dados do dispositivo. No entanto, o dispositivo não pode responder imediatamente, por isso preciso aguardar o retorno dessa ligação antes de continuar. Como existe atualmente, RequestToGetInputReport () é declarado assim:

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

Quanto vale a pena, a declaração para GetInputReportViaInterruptTransfer () é semelhante a esta:

internal async Task<int> GetInputReportViaInterruptTransfer()

Infelizmente, não estou muito familiarizado com o funcionamento das novas tecnologias async / wait no .NET 4.5. Eu fiz uma pequena leitura anterior sobre a palavra-chave wait e isso me deu a impressão de que a chamada para GetInputReportViaInterruptTransfer () dentro de RequestToGetInputReport () esperaria (e talvez espere?), Mas não parece ser a chamada para RequestToGetInputReport () em si está esperando porque parece que eu estou entrando novamente no loop while quase imediatamente?

Alguém pode esclarecer o comportamento que estou vendo?

Evite async void. Faça com que seus métodos retornem em Taskvez de void. Então você pode awaiteles.

Como isso:

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

A coisa mais importante a saber asynce awaité que await não espera a conclusão da chamada associada. O que awaitfaz é retornar o resultado da operação imediatamente e de forma síncrona se a operação já tiver sido concluída ou, se não tiver, agendar uma continuação para executar o restante do asyncmétodo e, em seguida, retornar o controle ao chamador. Quando a operação assíncrona for concluída, a conclusão agendada será executada.

A resposta para a pergunta específica no título da sua pergunta é bloquear asynco valor de retorno de um método (que deve ser do tipo Taskou Task<T>) chamando um Waitmétodo apropriado :

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

Nesse trecho de código, CallGetFooAsyncAndWaitOnResulté um invólucro síncrono em torno do método assíncrono GetFooAsync. No entanto, esse padrão deve ser evitado na maior parte do tempo, pois ele bloqueará um encadeamento de conjunto de encadeamentos inteiro durante a operação assíncrona. Esse é um uso ineficiente dos vários mecanismos assíncronos expostos pelas APIs que envidam grandes esforços para fornecê-los.

A resposta em "aguardar" não espera a conclusão da chamada tem várias explicações mais detalhadas dessas palavras-chave.

Enquanto isso, a orientação de Stephen Cleary sobre async voidretenções. Outras explicações interessantes sobre o porquê podem ser encontradas em http://www.tonicodes.net/blog/why-you-should-almost-never-write-void-asynchronous-methods/ e https://jaylee.org/archive/ 2012/07/08 / c-sharp-async-dicas-e-truques-parte-2-async-void.html

A melhor solução para esperar o AsynMethod até concluir a tarefa é

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

Aqui está uma solução alternativa usando um sinalizador:

//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 colocar Wait () para aguardar até que a tarefa seja concluída

GetInputReportViaInterruptTransfer().Wait();

Na verdade, achei isso mais útil para funções que retornam IAsyncAction.

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

O fragmento a seguir mostra uma maneira de garantir que o método esperado seja concluído antes de retornar ao chamador. No entanto, eu não diria que é uma boa prática. Por favor, edite minha resposta com explicações, se você pensa o contrário.

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

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