¿Enviar argumentos al trabajador de fondo?

Digamos que quiero enviar un parámetro int a un trabajador en segundo plano, ¿cómo se puede lograr esto?

private void worker_DoWork(object sender, DoWorkEventArgs e) {

}

Sé cuándo se trata de worker.RunWorkerAsync () ;, no entiendo cómo definir en worker_DoWork que debería tomar un parámetro int.

Lo comienzas así:

int value = 123;
bgw1.RunWorkerAsync(argument: value);  // the int will be boxed

y entonces

private void worker_DoWork(object sender, DoWorkEventArgs e) 
{
   int value = (int) e.Argument;   // the 'argument' parameter resurfaces here

   ...

   // and to transport a result back to the main thread
   double result = 0.1 * value;
   e.Result = result;
}


// the Completed handler should follow this pattern 
// for Error and (optionally) Cancellation handling
private void worker_Completed(object sender, RunWorkerCompletedEventArgs e) 
{
  // check error, check cancel, then use result
  if (e.Error != null)
  {
     // handle the error
  }
  else if (e.Cancelled)
  {
     // handle cancellation
  }
  else
  {          
      double result = (double) e.Result;
      // use it on the UI thread
  }
  // general cleanup code, runs when there was an error or not.
}

Aunque esta es una pregunta ya respondida, dejaría otra opción que IMO es mucho más fácil de leer:

BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += (obj, e) => WorkerDoWork(value, text);
worker.RunWorkerAsync();

Y en el método del controlador:

private void WorkerDoWork(int value, string text) {
    ...
}

Puede pasar múltiples argumentos como este.

List<object> arguments = new List<object>();
                    arguments.Add(argument 1);
                    arguments.Add(argument 1);
                    arguments.Add(argument n);


                    backgroundWorker2.RunWorkerAsync(arguments);

private void worker_DoWork(object sender, DoWorkEventArgs e) {

  List<object> genericlist = e.Argument as List<object>;
  extract your multiple arguments from this list and cast them and use them. 

}

Puedes usar el DoWorkEventArgs.Argument propiedad.

Se puede encontrar un ejemplo completo (incluso utilizando un argumento int) en el sitio de Microsoft:

• Cómo: ejecutar una operación en segundo plano

Consulte la propiedad DoWorkEventArgs.Argument :

...
backgroundWorker1.RunWorkerAsync(yourInt);
...

private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
    // Do not access the form's BackgroundWorker reference directly.
    // Instead, use the reference provided by the sender parameter.
    BackgroundWorker bw = sender as BackgroundWorker;

    // Extract the argument.
    int arg = (int)e.Argument;

    // Start the time-consuming operation.
    e.Result = TimeConsumingOperation(bw, arg);

    // If the operation was canceled by the user, 
    // set the DoWorkEventArgs.Cancel property to true.
    if (bw.CancellationPending)
    {
        e.Cancel = true;
    }
}

puede probar esto si desea pasar más de un tipo de argumentos, primero agréguelos todos a una matriz de tipo Object y pase ese objeto a RunWorkerAsync () aquí hay un ejemplo:

   some_Method(){
   List<string> excludeList = new List<string>(); // list of strings
   string newPath ="some path";  // normal string
   Object[] args = {newPath,excludeList };
            backgroundAnalyzer.RunWorkerAsync(args);
      }

Ahora en el método doWork de trabajador de fondo

backgroundAnalyzer_DoWork(object sender, DoWorkEventArgs e)
      {
        backgroundAnalyzer.ReportProgress(50);
        Object[] arg = e.Argument as Object[];
        string path= (string)arg[0];
        List<string> lst = (List<string>) arg[1];
        .......
        // do something......
        //.....
       }

Necesita el método RunWorkerAsync (objeto) y la propiedad DoWorkEventArgs.Argument .

worker.RunWorkerAsync(5);

private void worker_DoWork(object sender, DoWorkEventArgs e) {
    int argument = (int)e.Argument; //5
}

Siempre debe intentar usar un objeto compuesto con tipos concretos (usando un patrón de diseño compuesto) en lugar de una lista de tipos de objetos. ¿Quién recordaría qué diablos es cada uno de esos objetos? Piense en el mantenimiento de su código más adelante ... En su lugar, intente algo como esto:

Public (Class or Structure) MyPerson
                public string FirstName { get; set; }
                public string LastName { get; set; }
                public string Address { get; set; }
                public int ZipCode { get; set; }
End Class

Y entonces:

Dim person as new MyPerson With { .FirstName = “Joe”,
                                  .LastName = "Smith”,
                                  ...
                                 }
backgroundWorker1.RunWorkerAsync(person)

y entonces:

private void backgroundWorker1_DoWork (object sender, DoWorkEventArgs e)
{
        MyPerson person = e.Argument as MyPerson
        string firstname = person.FirstName;
        string lastname = person.LastName;
        int zipcode = person.ZipCode;                                 
}