Compartilhar via

Visão geral do componente BackgroundWorker

  • Artigo

Há muitas operações realizadas com frequência que podem levar muito tempo para serem executadas. Por exemplo:

  • Downloads de imagens

  • Invocações de serviço Web

  • Downloads e uploads de arquivos (inclusive de aplicativos ponto a ponto)

  • Cálculos locais complexos

  • Transações de banco de dados

  • Acesso ao disco local, dada a sua baixa velocidade em relação ao acesso à memória

Operações como essas podem fazer com que sua interface do usuário seja bloqueada enquanto eles estão em execução. Se você quer uma interface que responda com agilidade e está enfrentando longos atrasos associados a essas operações, o componente BackgroundWorker fornece uma solução conveniente.

O componente BackgroundWorker possibilita executar operações demoradas de forma assíncrona ("no segundo plano"), em um thread diferente do thread principal da interface do usuário do aplicativo. Para usar um BackgroundWorker, basta indicar o método de trabalho demorado que será executado em segundo plano e chamar o método RunWorkerAsync. Seu thread de chamada continua a funcionar normalmente enquanto o método de trabalho é executado de forma assíncrona. Quando o método é concluído, o BackgroundWorker alerta o thread de chamada disparando o evento RunWorkerCompleted, que contém, opcionalmente, os resultados da operação.

O BackgroundWorker componente está disponível na Caixa de Ferramentas, na guia Componentes. Para adicionar um BackgroundWorker ao formulário, arraste o componente para o BackgroundWorker formulário. Ele aparece na bandeja de componentes e suas propriedades aparecem na janela Propriedades.

Para iniciar a operação assíncrona, use o método RunWorkerAsync. RunWorkerAsync usa um parâmetro opcional object, que pode ser usado para passar argumentos para o seu método de trabalho. A classe BackgroundWorker expõe o evento DoWork, ao qual o seu thread de trabalho está anexado por meio de um manipulador de eventos DoWork.

O manipulador de eventos DoWork usa um parâmetro DoWorkEventArgs, que tem uma propriedade Argument. Esta propriedade recebe o parâmetro de RunWorkerAsync e pode ser passada para o seu método de trabalho, que será chamado no manipulador de eventos DoWork. O exemplo a seguir mostra como atribuir um resultado de um método de trabalho chamado ComputeFibonacci. Ele faz parte de um exemplo maior, que pode ser encontrado em Como implementar um formulário que usa uma operação em segundo plano.

// This event handler is where the actual,
// potentially time-consuming work is done.
void backgroundWorker1_DoWork( Object^ sender, DoWorkEventArgs^ e )
{
   // Get the BackgroundWorker that raised this event.
   BackgroundWorker^ worker = dynamic_cast<BackgroundWorker^>(sender);

   // Assign the result of the computation
   // to the Result property of the DoWorkEventArgs
   // object. This is will be available to the 
   // RunWorkerCompleted eventhandler.
   e->Result = ComputeFibonacci( safe_cast<Int32>(e->Argument), worker, e );
}

// This event handler is where the actual,
// potentially time-consuming work is done.
private void backgroundWorker1_DoWork(object sender,
    DoWorkEventArgs e)
{
    // Get the BackgroundWorker that raised this event.
    BackgroundWorker worker = sender as BackgroundWorker;

    // Assign the result of the computation
    // to the Result property of the DoWorkEventArgs
    // object. This is will be available to the
    // RunWorkerCompleted eventhandler.
    e.Result = ComputeFibonacci((int)e.Argument, worker, e);
}

' This event handler is where the actual work is done.
Private Sub backgroundWorker1_DoWork( _
ByVal sender As Object, _
ByVal e As DoWorkEventArgs) _
Handles backgroundWorker1.DoWork

    ' Get the BackgroundWorker object that raised this event.
    Dim worker As BackgroundWorker = _
        CType(sender, BackgroundWorker)

    ' Assign the result of the computation
    ' to the Result property of the DoWorkEventArgs
    ' object. This is will be available to the 
    ' RunWorkerCompleted eventhandler.
    e.Result = ComputeFibonacci(e.Argument, worker, e)
End Sub

Para obter mais informações sobre o uso de manipuladores de eventos, consulte Eventos.

Cuidado

O uso de multithreading de qualquer tipo pode expor o computador a bugs muito sérios e complexos. Consulte as Melhores práticas de threading gerenciado antes de implementar qualquer solução que use multithreading.

Para obter mais informações sobre como usar a BackgroundWorker classe, consulte Como: Executar uma operação em segundo plano.

Confira também