Assíncrono / espera versus BackgroundWorker

Nos últimos dias, testei os novos recursos do .net 4.5 e c # 5.

Eu gosto de seus novos recursos assíncronos / aguardados. Anteriormente, eu havia usado o BackgroundWorker para lidar com processos mais longos em segundo plano com a interface do usuário responsiva.

Minha pergunta é: depois de ter esses novos recursos, quando devo usar async / waitit e quando um BackgroundWorker ? Quais são os cenários comuns para ambos?

assíncrono / espera é projetado para substituir construções como o BackgroundWorker. Embora você certamente possa usá-lo, se quiser, poderá usar async / waitit, juntamente com algumas outras ferramentas TPL, para lidar com tudo o que existe por aí.

Como os dois funcionam, tudo se resume à preferência pessoal sobre a qual você usa quando. O que é mais rápido para você ? O que é mais fácil para você entender?

É provável que TL; DR para muitos, mas acho que comparar awaitcom BackgroundWorkeré como comparar maçãs e laranjas e meus pensamentos sobre isso a seguir:

BackgroundWorkerdestina-se a modelar uma única tarefa que você deseja executar em segundo plano, em um thread do conjunto de threads. async/ awaitÉ uma sintaxe para de forma assíncrona aguardando em operações assíncronas. Essas operações podem ou não usar um encadeamento de conjunto de encadeamentos ou até mesmo usar outro encadeamento . Então, são maçãs e laranjas.

Por exemplo, você pode fazer algo como o seguinte com await:

using (WebResponse response = await webReq.GetResponseAsync())
{
    using (Stream responseStream = response.GetResponseStream())
    {
        int bytesRead = await responseStream.ReadAsync(buffer, 0, buffer.Length);
    }
}

Mas, você provavelmente nunca modelaria isso em um trabalhador em segundo plano, provavelmente faria algo assim no .NET 4.0 (antes await):

webReq.BeginGetResponse(ar =>
{
    WebResponse response = webReq.EndGetResponse(ar);
    Stream responseStream = response.GetResponseStream();
    responseStream.BeginRead(buffer, 0, buffer.Length, ar2 =>
    {
        int bytesRead = responseStream.EndRead(ar2);
        responseStream.Dispose();
        ((IDisposable) response).Dispose();
    }, null);
}, null);

Observe a disjunção do descarte comparada entre as duas sintaxes e como você não pode usar usingsem async/ await.

Mas você não faria algo assim com BackgroundWorker. BackgroundWorkergeralmente é para modelar uma única operação de longa duração que você não deseja afetar a capacidade de resposta da interface do usuário. Por exemplo:

worker.DoWork += (sender, e) =>
                    {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                        ++i;
                    };
worker.RunWorkerCompleted += (sender, eventArgs) =>
                                {
                                    // TODO: do something on the UI thread, like
                                    // update status or display "result"
                                };
worker.RunWorkerAsync();

Não há realmente nada lá com o qual você possa usar async / waitit BackgroundWorkeresteja criando o thread para você.

Agora, você pode usar o TPL:

var synchronizationContext = TaskScheduler.FromCurrentSynchronizationContext();
Task.Factory.StartNew(() =>
                      {
                        int i = 0;
                        // simulate lengthy operation
                        Stopwatch sw = Stopwatch.StartNew();
                        while (sw.Elapsed.TotalSeconds < 1)
                            ++i;
                      }).ContinueWith(t=>
                                      {
                                        // TODO: do something on the UI thread, like
                                        // update status or display "result"
                                      }, synchronizationContext);

Nesse caso, o TaskSchedulerestá criando o encadeamento para você (assumindo o padrão TaskScheduler) e pode ser usado da awaitseguinte maneira:

await Task.Factory.StartNew(() =>
                  {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                        ++i;
                  });
// TODO: do something on the UI thread, like
// update status or display "result"

Na minha opinião, uma grande comparação é se você está relatando progresso ou não. Por exemplo, você pode ter BackgroundWorker likeisso:

BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.ProgressChanged += (sender, eventArgs) =>
                            {
                            // TODO: something with progress, like update progress bar

                            };
worker.DoWork += (sender, e) =>
                 {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                    {
                        if ((sw.Elapsed.TotalMilliseconds%100) == 0)
                            ((BackgroundWorker)sender).ReportProgress((int) (1000 / sw.ElapsedMilliseconds));
                        ++i;
                    }
                 };
worker.RunWorkerCompleted += (sender, eventArgs) =>
                                {
                                    // do something on the UI thread, like
                                    // update status or display "result"
                                };
worker.RunWorkerAsync();

Mas você não lidaria com isso porque arrastaria e soltaria o componente de trabalho em segundo plano na superfície de design de um formulário - algo que não pode ser feito com async/ awaite Task... ou seja, você venceu ' t crie manualmente o objeto, defina as propriedades e os manipuladores de eventos. você só preencher o corpo dos DoWork, RunWorkerCompletede ProgressChangedmanipuladores de eventos.

Se você "converteu" isso em assíncrono / espera, faria algo como:

     IProgress<int> progress = new Progress<int>();

     progress.ProgressChanged += ( s, e ) =>
        {
           // TODO: do something with e.ProgressPercentage
           // like update progress bar
        };

     await Task.Factory.StartNew(() =>
                  {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                    {
                        if ((sw.Elapsed.TotalMilliseconds%100) == 0)
                        {
                            progress.Report((int) (1000 / sw.ElapsedMilliseconds))
                        }
                        ++i;
                    }
                  });
// TODO: do something on the UI thread, like
// update status or display "result"

Sem a capacidade de arrastar um componente para uma superfície do Designer, cabe ao leitor decidir qual é "melhor". Mas, para mim, essa é a comparação entre awaite BackgroundWorker, não se você pode aguardar métodos internos como Stream.ReadAsync. por exemplo, se você estiver usando BackgroundWorkercomo pretendido, pode ser difícil converter para usar await.

Outras opiniões: http://jeremybytes.blogspot.ca/2012/05/backgroundworker-component-im-not-dead.html

Esta é uma boa introdução: http://msdn.microsoft.com/en-us/library/hh191443.aspx A seção Threads é exatamente o que você está procurando:

Os métodos assíncronos devem ser operações sem bloqueio. Uma expressão de espera em um método assíncrono não bloqueia o encadeamento atual enquanto a tarefa aguardada está em execução. Em vez disso, a expressão inscreve o restante do método como uma continuação e retorna o controle para o chamador do método assíncrono.

As palavras-chave assíncronas e aguardam não fazem com que threads adicionais sejam criados. Os métodos assíncronos não requerem multithreading porque um método assíncrono não é executado em seu próprio encadeamento. O método é executado no contexto de sincronização atual e usa o tempo no encadeamento apenas quando o método está ativo. Você pode usar o Task.Run para mover o trabalho vinculado à CPU para um encadeamento em segundo plano, mas um encadeamento em segundo plano não ajuda em um processo que está apenas aguardando a disponibilização dos resultados.

A abordagem assíncrona da programação assíncrona é preferível às abordagens existentes em quase todos os casos. Em particular, essa abordagem é melhor que o BackgroundWorker para operações vinculadas à IO porque o código é mais simples e você não precisa se proteger contra as condições de corrida. Em combinação com o Task.Run, a programação assíncrona é melhor que o BackgroundWorker para operações ligadas à CPU porque a programação assíncrona separa os detalhes de coordenação da execução do seu código do trabalho que o Task.Run transfere para o conjunto de threads.

BackgroundWorker é explicitamente rotulado como obsoleto no .NET 4.5:

• no livro Por Joseph Albahari, Ben Albahari "C # 5.0 em poucas palavras: a referência definitiva"
• Resposta de Stephen Cleary à minha pergunta "Não foi o .NET 4.0 TPL que tornou obsoletos os padrões assíncronos do APM, EAP e BackgroundWorker?"

O artigo do MSDN "Programação assíncrona com Async e Await (C # e Visual Basic)" informa:

A abordagem assíncrona da programação assíncrona é preferível às abordagens existentes em quase todos os casos . Em particular, essa abordagem é melhor que o BackgroundWorker para operações vinculadas à IO porque o código é mais simples e você não precisa se proteger contra as condições de corrida. Em combinação com o Task.Run, a programação assíncrona é melhor que o BackgroundWorker para operações vinculadas à CPU porque a programação assíncrona separa os detalhes de coordenação da execução do código do trabalho que o Task.Run transfere para o conjunto de threads

ATUALIZAR

• em resposta ao comentário de @ eran-otzap :
  "para operações com IO porque o código é mais simples e você não precisa se proteger contra as condições da corrida" Que condições da corrida podem ocorrer, você poderia dar um exemplo? "

Esta pergunta deveria ter sido colocada como um post separado.

A Wikipedia tem uma boa explicação das condições de corrida . A parte necessária é multithreading e do mesmo artigo do MSDN Programação assíncrona com Async e Await (C # e Visual Basic) :

Os métodos assíncronos devem ser operações sem bloqueio. Uma expressão de espera em um método assíncrono não bloqueia o encadeamento atual enquanto a tarefa aguardada está em execução. Em vez disso, a expressão inscreve o restante do método como uma continuação e retorna o controle para o chamador do método assíncrono.

As palavras-chave assíncronas e aguardam não fazem com que threads adicionais sejam criados. Os métodos assíncronos não requerem multithreading porque um método assíncrono não é executado em seu próprio encadeamento. O método é executado no contexto de sincronização atual e usa o tempo no encadeamento apenas quando o método está ativo. Você pode usar o Task.Run para mover o trabalho vinculado à CPU para um encadeamento em segundo plano, mas um encadeamento em segundo plano não ajuda em um processo que está apenas aguardando a disponibilização dos resultados.

A abordagem assíncrona da programação assíncrona é preferível às abordagens existentes em quase todos os casos. Em particular, essa abordagem é melhor que o BackgroundWorker para operações vinculadas à IO porque o código é mais simples e você não precisa se proteger contra as condições de corrida. Em combinação com o Task.Run, a programação assíncrona é melhor que o BackgroundWorker para operações vinculadas à CPU porque a programação assíncrona separa os detalhes de coordenação da execução do código do trabalho que o Task.Run transfere para o conjunto de threads

Ou seja, "As palavras-chave assíncronas e aguardam não causam a criação de threads adicionais".

Tanto quanto me lembro de minhas próprias tentativas, quando eu estava estudando este artigo, há um ano, se você executou e brincou com um exemplo de código do mesmo artigo, poderá encontrar situações nas versões não assíncronas (você pode tentar converter bloqueie indefinidamente!

Além disso, para exemplos concretos, você pode pesquisar neste site. Aqui estão alguns exemplos:

• Chamando um método assíncrono com c # 5.0
• Por que esse código falha quando executado via TPL / Tasks?
• aguardar vs Task.Wait - Deadlock?