Tutorial: Multithreading con el componente BackgroundWorker (C# y Visual Basic)

En este tutorial se muestra cómo crear aplicaciones multiproceso que buscan en archivos de texto las apariciones de palabras. Explica cómo:

• Definir una clase con un método al que puede llamar el componente BackgroundWorker.

• Controlar eventos iniciados por el componente BackgroundWorker.

• Iniciar un componente BackgroundWorker para ejecutar un método.

• Implementar un botón Cancel que detiene el componente BackgroundWorker.

Para crear la interfaz de usuario

1. Abra un nuevo proyecto de aplicación Windows en Visual Basic o C# y cree un formulario denominado Form1.

2. Agregue dos botones y cuatro cuadros de texto a Form1.

3. Dé nombre a los objetos como se muestra en la tabla siguiente.

   Objeto	Propiedad	Valor
   Primer botón	Name, Text	Start, Start
   Segundo botón	Name, Text	Cancel, Cancel
   Primer cuadro de texto	Name, Text	SourceFile, ""
   Segundo cuadro de texto	Name, Text	CompareString, ""
   Tercer cuadro de texto	Name, Text	WordsCounted, "0"
   Cuarto cuadro de texto	Name, Text	LinesCounted, "0"

4. Agregue una etiqueta a cada cuadro de texto. Establezca la propiedad Text de cada etiqueta como se muestra en la tabla siguiente.

   Objeto	Propiedad	Valor
   Primera etiqueta	Text	Archivo de origen
   Segunda etiqueta	Text	Compare String
   Tercera etiqueta	Text	Matching Words
   Cuarta etiqueta	Text	Lines Counted

Para crear un componente BackgroundWorker y suscribirse a sus eventos

1. Agregue al formulario un componente BackgroundWorker desde la sección Componentes del Cuadro de herramientas. Aparecerá en la bandeja de componentes del formulario.

2. Establezca las siguientes propiedades del objeto BackgroundWorker1 en Visual Basic o del objeto backgroundWorker1 en C#.

   Propiedad	Valor
   WorkerReportsProgress	True
   WorkerSupportsCancellation	True

3. Solo en C#, suscríbase a los eventos del objeto backgroundWorker1. En la parte superior de la ventana Propiedades, haga clic en el icono Eventos. Haga doble clic en el evento RunWorkerCompleted para crear un método de control de eventos. Siga el mismo procedimiento para los eventos ProgressChanged y DoWork.

Para definir el método que se ejecutará en un subproceso aparte

1. En el menú Proyecto, elija Agregar clase para agregar una clase al proyecto. Se abrirá el cuadro de diálogo Agregar nuevo elemento.

2. En la ventana de plantillas, seleccione Clase y, a continuación, escriba Words.vb o Words.cs en el campo de nombre.

3. Haga clic en Agregar. Se muestra la clase Words.

4. Agregue el código siguiente a la clase Words:

   Public Class Words
       ' Object to store the current state, for passing to the caller.
       Public Class CurrentState
           Public LinesCounted As Integer
           Public WordsMatched As Integer
       End Class
   
       Public SourceFile As String
       Public CompareString As String
       Private WordCount As Integer = 0
       Private LinesCounted As Integer = 0
   
       Public Sub CountWords(
           ByVal worker As System.ComponentModel.BackgroundWorker,
           ByVal e As System.ComponentModel.DoWorkEventArgs
       )
           ' Initialize the variables.
           Dim state As New CurrentState
           Dim line = ""
           Dim elapsedTime = 20
           Dim lastReportDateTime = Now
   
           If CompareString Is Nothing OrElse
              CompareString = System.String.Empty Then
   
              Throw New Exception("CompareString not specified.")
           End If
   
           Using myStream As New System.IO.StreamReader(SourceFile)
   
               ' Process lines while there are lines remaining in the file.
               Do While Not myStream.EndOfStream
                   If worker.CancellationPending Then
                       e.Cancel = True
                       Exit Do
                   Else
                       line = myStream.ReadLine
                       WordCount += CountInString(line, CompareString)
                       LinesCounted += 1
   
                       ' Raise an event so the form can monitor progress.
                       If Now > lastReportDateTime.AddMilliseconds(elapsedTime) Then
                           state.LinesCounted = LinesCounted
                           state.WordsMatched = WordCount
                           worker.ReportProgress(0, state)
                           lastReportDateTime = Now
                       End If
   
                       ' Uncomment for testing.
                       'System.Threading.Thread.Sleep(5)
                   End If
               Loop
   
               ' Report the final count values.
               state.LinesCounted = LinesCounted
               state.WordsMatched = WordCount
               worker.ReportProgress(0, state)
           End Using
       End Sub
   
       Private Function CountInString(
           ByVal SourceString As String,
           ByVal CompareString As String
       ) As Integer
           ' This function counts the number of times
           ' a word is found in a line.
           If SourceString Is Nothing Then
               Return 0
           End If
   
           Dim EscapedCompareString =
               System.Text.RegularExpressions.Regex.Escape(CompareString)
   
           Dim regex As New System.Text.RegularExpressions.Regex(
               EscapedCompareString,
               System.Text.RegularExpressions.RegexOptions.IgnoreCase)
   
           Dim matches As System.Text.RegularExpressions.MatchCollection
           matches = regex.Matches(SourceString)
           Return matches.Count
       End Function
   End Class
   

   public class Words
   {
       // Object to store the current state, for passing to the caller.
       public class CurrentState
       {
           public int LinesCounted;
           public int WordsMatched;
       }
   
       public string SourceFile;
       public string CompareString;
       private int WordCount;
       private int LinesCounted;
   
       public void CountWords(
           System.ComponentModel.BackgroundWorker worker,
           System.ComponentModel.DoWorkEventArgs e)
       {
           // Initialize the variables.
           CurrentState state = new CurrentState();
           string line = "";
           int elapsedTime = 20;
           DateTime lastReportDateTime = DateTime.Now;
   
           if (CompareString == null ||
               CompareString == System.String.Empty)
           {
               throw new Exception("CompareString not specified.");
           }
   
           // Open a new stream.
           using (System.IO.StreamReader myStream = new System.IO.StreamReader(SourceFile))
           {
               // Process lines while there are lines remaining in the file.
               while (!myStream.EndOfStream)
               {
                   if (worker.CancellationPending)
                   {
                       e.Cancel = true;
                       break;
                   }
                   else
                   {
                       line = myStream.ReadLine();
                       WordCount += CountInString(line, CompareString);
                       LinesCounted += 1;
   
                       // Raise an event so the form can monitor progress.
                       int compare = DateTime.Compare(
                           DateTime.Now, lastReportDateTime.AddMilliseconds(elapsedTime));
                       if (compare > 0)
                       {
                           state.LinesCounted = LinesCounted;
                           state.WordsMatched = WordCount;
                           worker.ReportProgress(0, state);
                           lastReportDateTime = DateTime.Now;
                       }
                   }
                   // Uncomment for testing.
                   //System.Threading.Thread.Sleep(5);
               }
   
               // Report the final count values.
               state.LinesCounted = LinesCounted;
               state.WordsMatched = WordCount;
               worker.ReportProgress(0, state);
           }
       }
   
   
       private int CountInString(
           string SourceString,
           string CompareString)
       {
           // This function counts the number of times
           // a word is found in a line.
           if (SourceString == null)
           {
               return 0;
           }
   
           string EscapedCompareString =
               System.Text.RegularExpressions.Regex.Escape(CompareString);
   
           System.Text.RegularExpressions.Regex regex;
           regex = new System.Text.RegularExpressions.Regex( 
               EscapedCompareString,
               System.Text.RegularExpressions.RegexOptions.IgnoreCase);
   
           System.Text.RegularExpressions.MatchCollection matches;
           matches = regex.Matches(SourceString);
           return matches.Count;
       }
   
   }
   

Para tratar eventos desde el subproceso

• Agregue los controladores de eventos siguientes a su formulario principal.

  Private Sub BackgroundWorker1_RunWorkerCompleted( 
      ByVal sender As Object, 
      ByVal e As System.ComponentModel.RunWorkerCompletedEventArgs
    ) Handles BackgroundWorker1.RunWorkerCompleted
  
      ' This event handler is called when the background thread finishes.
      ' This method runs on the main thread.
      If e.Error IsNot Nothing Then
          MessageBox.Show("Error: " & e.Error.Message)
      ElseIf e.Cancelled Then
          MessageBox.Show("Word counting canceled.")
      Else
          MessageBox.Show("Finished counting words.")
      End If
  End Sub
  
  Private Sub BackgroundWorker1_ProgressChanged( 
      ByVal sender As Object, 
      ByVal e As System.ComponentModel.ProgressChangedEventArgs
    ) Handles BackgroundWorker1.ProgressChanged
  
      ' This method runs on the main thread.
      Dim state As Words.CurrentState = 
          CType(e.UserState, Words.CurrentState)
      Me.LinesCounted.Text = state.LinesCounted.ToString
      Me.WordsCounted.Text = state.WordsMatched.ToString
  End Sub
  

  private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
  {
  // This event handler is called when the background thread finishes.
  // This method runs on the main thread.
  if (e.Error != null)
      MessageBox.Show("Error: " + e.Error.Message);
  else if (e.Cancelled)
      MessageBox.Show("Word counting canceled.");
  else
      MessageBox.Show("Finished counting words.");
  }
  
  private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
  {
      // This method runs on the main thread.
      Words.CurrentState state =
          (Words.CurrentState)e.UserState;
      this.LinesCounted.Text = state.LinesCounted.ToString();
      this.WordsCounted.Text = state.WordsMatched.ToString();
  }
  

Para iniciar y llamar a un nuevo subproceso que ejecuta el método WordCount

1. Agregue a su programa el procedimiento siguiente:

   Private Sub BackgroundWorker1_DoWork( 
       ByVal sender As Object, 
       ByVal e As System.ComponentModel.DoWorkEventArgs
     ) Handles BackgroundWorker1.DoWork
   
       ' This event handler is where the actual work is done.
       ' This method runs on the background thread.
   
       ' Get the BackgroundWorker object that raised this event.
       Dim worker As System.ComponentModel.BackgroundWorker
       worker = CType(sender, System.ComponentModel.BackgroundWorker)
   
       ' Get the Words object and call the main method.
       Dim WC As Words = CType(e.Argument, Words)
       WC.CountWords(worker, e)
   End Sub
   
   Sub StartThread()
       ' This method runs on the main thread.
       Me.WordsCounted.Text = "0"
   
       ' Initialize the object that the background worker calls.
       Dim WC As New Words
       WC.CompareString = Me.CompareString.Text
       WC.SourceFile = Me.SourceFile.Text
   
       ' Start the asynchronous operation.
       BackgroundWorker1.RunWorkerAsync(WC)
   End Sub
   

   private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
   {
       // This event handler is where the actual work is done.
       // This method runs on the background thread.
   
       // Get the BackgroundWorker object that raised this event.
       System.ComponentModel.BackgroundWorker worker;
       worker = (System.ComponentModel.BackgroundWorker)sender;
   
       // Get the Words object and call the main method.
       Words WC = (Words)e.Argument;
       WC.CountWords(worker, e);
   }
   
   private void StartThread()
   {
       // This method runs on the main thread.
       this.WordsCounted.Text = "0";
   
       // Initialize the object that the background worker calls.
       Words WC = new Words();
       WC.CompareString = this.CompareString.Text;
       WC.SourceFile = this.SourceFile.Text;
   
       // Start the asynchronous operation.
       backgroundWorker1.RunWorkerAsync(WC);
   }
   

2. Llame al método StartThread desde el botón Start del formulario:

   Private Sub Start_Click() Handles Start.Click
       StartThread()
   End Sub
   

   private void Start_Click(object sender, EventArgs e)
   {
       StartThread();
   }
   

Para implementar el botón Cancel que detiene el subproceso

• Llame al procedimiento StopThread desde el controlador de evento Click para el botón Cancel.

  Private Sub Cancel_Click() Handles Cancel.Click
      ' Cancel the asynchronous operation.
      Me.BackgroundWorker1.CancelAsync()
  End Sub
  

  private void Cancel_Click(object sender, EventArgs e)
  {
      // Cancel the asynchronous operation.
      this.backgroundWorker1.CancelAsync();
  }
  

Pruebas

Ahora puede probar la aplicación para asegurarse de que funciona correctamente.

Para probar la aplicación

1. Presione F5 para ejecutar la aplicación.

2. Cuando se muestre el formulario, escriba la ruta de acceso al archivo que desea probar en el cuadro sourceFile. Por ejemplo, suponiendo que el nombre del archivo de prueba es Prueba.txt, escriba C:\Prueba.txt.

3. En el segundo cuadro de texto, escriba una palabra o frase para que la aplicación la busque en el archivo de texto.

4. Haga clic en el botón Start. El botón LinesCounted empezará a incrementar inmediatamente. La aplicación mostrará el mensaje "Finished Counting" cuando termine.

Para comprobar el botón Cancel

1. Presione F5 para iniciar la aplicación y escriba el nombre de archivo y la palabra de búsqueda como se describe en el procedimiento anterior. Asegúrese de que el archivo que elige es lo suficientemente grande para que le dé tiempo a cancelar el procedimiento antes de que termine.

2. Haga clic en el botón Start para iniciar la aplicación.

3. Haga clic en el botón Cancel. La aplicación parará de contar inmediatamente.

Pasos siguientes

Esta aplicación contiene algunos ejemplos de control básico de errores. Detecta las cadenas de búsqueda en blanco. Puede ampliar este programa tratando otros errores, como la superación del número máximo de palabras o líneas que se pueden contabilizar.

Vea también

Tareas

Tutorial: Crear un componente sencillo con múltiples procesos en Visual Basic

Cómo: Suscribir y cancelar la suscripción a eventos (Guía de programación de C#)

Referencia

Subprocesamiento (C# y Visual Basic)