Enviando argumentos para o trabalhador em segundo plano?

Digamos que eu queira enviar um parâmetro int para um trabalhador em segundo plano, como isso pode ser feito?

private void worker_DoWork(object sender, DoWorkEventArgs e) {

}

Eu sei quando isso é worker.RunWorkerAsync () ;, eu não entendo como definir em worker_DoWork que ele deve usar um parâmetro int.

Você começa assim:

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

e depois

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.
}

Mesmo que essa seja uma pergunta já respondida, deixaria outra opção que a IMO é muito mais fácil de ler:

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

E no método manipulador:

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

Você pode passar vários 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. 

}

Você pode usar a DoWorkEventArgs.Argumentpropriedade

Um exemplo completo (mesmo usando um argumento int) pode ser encontrado no site da Microsoft:

• Como executar uma operação em segundo plano

Confira a propriedade 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;
    }
}

você pode tentar fazer isso se quiser passar mais de um tipo de argumento, primeiro adicione todos eles a uma matriz do tipo Object e passe esse objeto para RunWorkerAsync (). Aqui está um exemplo:

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

Agora no método doWork de trabalho em segundo plano

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......
        //.....
       }

Você precisa do método RunWorkerAsync (objeto) e da propriedade DoWorkEventArgs.Argument .

worker.RunWorkerAsync(5);

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

Você deve sempre tentar usar um objeto composto com tipos concretos (usando padrão de design composto) em vez de uma lista de tipos de objetos. Quem se lembraria do que diabos é cada um desses objetos? Pense na manutenção do seu código mais tarde ... Em vez disso, tente algo como isto:

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

E depois:

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

e depois:

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;                                 
}