dev .NET en español (neat!)

Nota: Ejemplo completo de uso del control BackgroundWorker. El artículo inicial se creó en inglés y fue publicado aquí. En vista del éxito que ha tenido lo traduzco al castellano y lo republico también en este apartado.

Introducción

El control BackgroundWorker fue introducido en el .NET Framework 2.0 y permite realizar operaciones costosas o duraderas en un hilo diferente al del interfaz, de manera que la aplicación sigue respondiendo al usuario mientras este trabajo se procesa en segundo plano.

Usando este control, la gestión de hilos está encapsulada en el control de manera que el programador no tiene que lidiar con hilos (threads), invokes o delegados (delegates).

Ejemplo

Este sencillo ejemplo cubre prácticamente todas las posibilidades de este componente: soporte de cancelación, gestión de errores , información de progreso (y ejemplo de como pasar información en cada notificación de progreso)

Evento backgroundWorker1_DoWork

El evento backgroundWorker1_DoWork es desencadenado por el control cuando el método RunWorkerAsync() es invocado. Este método se ejecuta en un segundo hilo que crea el control BackgroundWorker. Al no ser el hilo principal del interfaz, no intentes acceder a ningún control aquí, o si lo haces utiliza para ello un delegado.

        //[System.Diagnostics.DebuggerNonUserCodeAttribute()]  (*)
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            //no usaremos código try/catch aquí, a no ser que después hagamos un throw de la excepción capturada.
            //es necesario dejar que el backgroundworker sea quien capture cualquier excepción producida.
            //si se produce una excepción, el control la disponibilizará una vez haya finalizado su ejecución,
            //y disparado el evento "backgroundWorker1_RunWorkerCompleted"
            //the RunWorkerCompletedEventArgs object, method backgroundWorker1_RunWorkerCompleted
            //try
            //{
                DateTime start = DateTime.Now;
                e.Result = "";
                for (int i = 0; i < 100; i++)
                {
                    System.Threading.Thread.Sleep(50); //simulamos trabajo

                   //hemos completado un porcentaje del trabajo previsto, luego notificamos de ello.
                    backgroundWorker1.ReportProgress(i, DateTime.Now);

                    //descomenta este código para ver como esta excepción es gestionada por el
                    //control backgroundworker
                    //descomenta también el atributo indicado arriba para evitar que el depurador
                    //pare en la excepción, ya que queremos simular
                    //el comportamiento del control en tiempo de ejecución.
                    //if (i == 34)
                    //    throw new Exception("something wrong here!!");

                    //en caso de que soporte cancelación y el control haya recibido la petición de cancelación,
                    //cancelamos el trabajo. Es la manera en la que realizamos una salida "limpia".
                    if (backgroundWorker1.CancellationPending)
                    {
                        e.Cancel = true;
                        return;
                    }
                }

                TimeSpan duration = DateTime.Now - start;

                //aquí podríamos devolver información de utilidad, como el resultado de un cálculo,
                //número de elementos afectados, etc.. de manera sencilla y segura
                //al hilo principal
                e.Result = "Duration: " + duration.TotalMilliseconds.ToString() + " ms.";
            //}
            //catch(Exception ex){
            //    MessageBox.Show("Don't use try catch here!");
            //}
        }

(*) Nota: El atributo [System.Diagnostics.DebuggerNonUserCodeAttribute()] es necesario para evitar que el depurador interrumpa el flujo de la ejecución en caso de que una excepción se produzca. De esta manera podemos trabajar en modo depuración con el mismo comportamiento que el control tendría en modo ejecución. Este comportamiento consistiría en capturar internamente la excepción (por eso no usaremos try/catch en el método) y devolvernos la misma junto con el resultado, en el método backgroundWorker1_RunWorkerCompleted

Evento backgroundWorker1_ProgressChanged

Este evento es lanzado en el hilo principal, por lo que aquí SI podemos acceder a controles del formulario de manera segura.

 private void backgroundWorker1_ProgressChanged(object sender,
 ProgressChangedEventArgs e)
 {
    progressBar1.Value = e.ProgressPercentage; //actualizamos la barra de progreso
    DateTime time = Convert.ToDateTime(e.UserState); //obtenemos información adicional si procede

    //en este ejemplo, logamos a un textbox
    txtOutput.AppendText(time.ToLongTimeString());
    txtOutput.AppendText(Environment.NewLine);
 }

Evento backgroundWorker1_RunWorkerCompleted

Este método se ejecuta cuando la tarea ha sido finalizada. Una tarea se finaliza cuando:

• a) termina de manera normal
• b) termina con error
• c) es cancelada.

En el objeto de tipo RunWorkerCompletedEventArgs encontraremos información detallada del tipo de finalización, así como los datos que hemos podido pasar en la propiedad Result.

 private void backgroundWorker1_RunWorkerCompleted(object sender,
 RunWorkerCompletedEventArgs e)
 {
    if (e.Cancelled) {
      MessageBox.Show("The task has been cancelled");
    }
    else if (e.Error != null)
    {
      MessageBox.Show("Error. Details: " + (e.Error as Exception).ToString());
    }
    else {
      MessageBox.Show("The task has been completed. Results: " + e.Result.ToString());
    }
 }

Enviado las órdenes de inicio y cancelación al control

Notificamos al control backgroundworker de que cancele el proceso.

 private void btoCancel_Click(object sender, EventArgs e)
 {
    //este código no mata ni afecta al hilo en el que se está ejecutando el procesamiento.
    //Sirve a efectos de notificación, que debe de ser
    //gestionada de la manera que se indica arriba en el ejemplo
    backgroundWorker1.CancelAsync();
 }

Lanzamos el trabajo. En este momento, el control backgroundworker lanza un hilo en el que ejecuta la tarea asignada, a través del método backgroundWorker1_DoWork visto anteriormente.

 private void btoStart_Click(object sender, EventArgs e)
 {
 backgroundWorker1.RunWorkerAsync();
 }