Información general sobre el componente BackgroundWorker

Actualización: noviembre 2007

Muchas operaciones que se realizan habitualmente pueden tardar mucho tiempo en ejecutarse. Por ejemplo:

• Descargas de imágenes

• Invocaciones del servicio Web

• Descargas y cargas de archivos (incluso para las aplicaciones punto a punto)

• Cálculos locales complejos

• Transacciones de base de datos

• Acceso del disco local, dada su baja velocidad relativa al acceso a memoria

Este tipo de operaciones pueden hacer que la interfaz de usuario se bloquee mientras se están ejecutando. Si desea una interfaz de usuario receptiva y se está encontrando con grandes retrasos asociados a tales operaciones, el componente BackgroundWorker proporciona una solución adecuada.

El componente BackgroundWorker le proporciona la capacidad de ejecutar operaciones que llevan mucho tiempo de forma asincrónica ("en segundo plano"), en un subproceso diferente del subproceso principal de la interfaz de usuario de la aplicación. Para utilizar BackgroundWorker, simplemente hay que indicarle el método de trabajo cuya ejecución en segundo plano lleva mucho tiempo y, a continuación, llamar al método RunWorkerAsync. El subproceso que hace la llamada continúa normalmente ejecutándose normalmente mientras el método de trabajo se ejecuta de forma asincrónica. Cuando finaliza el método, BackgroundWorker avisa el subproceso que hace la llamada desencadenando el evento RunWorkerCompleted, que puede contener los resultados de la operación.

El componente BackgroundWorker está disponible en la ficha Componentes del Cuadro de herramientas. Para agregar BackgroundWorker al formulario, arrastre el componente BackgroundWorker al formulario. Aparece en la bandeja de componentes, y sus propiedades se muestran en la ventana Propiedades.

Para iniciar la operación asincrónica, utilice el método RunWorkerAsync. RunWorkerAsync toma un parámetro object opcional, que se utiliza para pasar argumentos al método de trabajo. La clase BackgroundWorker expone el evento DoWork, a cuyo subproceso de trabajo se asocia a través del controlador de eventos DoWork.

El controlador de eventos DoWork toma un parámetro DoWorkEventArgs, que tiene una propiedad Argument. Esta propiedad recibe el parámetro de RunWorkerAsync y se puede pasar al método de trabajo, que se llamará en el controlador de eventos DoWork. En el ejemplo siguiente se muestra cómo asignar un resultado de un método de trabajo llamado ComputeFibonacci. Forma parte de un ejemplo más extenso, que puede encontrar en Cómo: Implementar un formulario que utiliza una operación en segundo plano.

' 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 'backgroundWorker1_DoWork

// 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,
// 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 = (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.set_Result(new Long(ComputeFibonacci(System.Convert.ToInt32
        (e.get_Argument()), worker, e)));
    //e.Result = ComputeFibonacci((int)e.Argument, worker, e); 
} //backgroundWorker1_DoWork

Para obtener más información acerca de cómo utilizar los controladores de eventos, vea Eventos y delegados.

Precaución:
Al utilizar subprocesamiento múltiple de cualquier tipo, se expone potencialmente a errores muy graves y complejos. Consulte Procedimientos recomendados para el subprocesamiento administrado antes de implementar cualquier solución que utilice el subprocesamiento múltiple.

Para obtener más información sobre el uso de la clase BackgroundWorker, vea Cómo: Ejecutar una operación en segundo plano.

Vea también

Tareas

Cómo: Implementar un formulario que utiliza una operación en segundo plano

Otros recursos

Subprocesamiento múltiple en Visual Basic