Envoi d'arguments à l'agent d'arrière-plan?

Disons que je veux envoyer un paramètre int à un travailleur d'arrière-plan, comment cela peut-il être accompli?

private void worker_DoWork(object sender, DoWorkEventArgs e) {

}

Je sais quand il s'agit de worker.RunWorkerAsync () ;, Je ne comprends pas comment définir dans worker_DoWork qu'il devrait prendre un paramètre int.

Vous démarrez comme ceci:

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

puis

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

Même s'il s'agit d'une question déjà répondue, je laisserais une autre option que l'OMI est beaucoup plus facile à lire:

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

Et sur la méthode du gestionnaire:

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

Vous pouvez passer plusieurs arguments comme celui-ci.

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. 

}

Vous pouvez utiliser la DoWorkEventArgs.Argumentpropriété.

Un exemple complet (même en utilisant un argument int) peut être trouvé sur le site de Microsoft:

• Guide pratique: exécuter une opération en arrière-plan

Découvrez la propriété 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;
    }
}

vous pouvez essayer ceci si vous voulez passer plus d'un type d'arguments, ajoutez-les d'abord tous à un tableau de type Object et passez cet objet à RunWorkerAsync () voici un exemple:

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

Maintenant dans la méthode doWork de background worker

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

Vous avez besoin de la méthode RunWorkerAsync (objet) et de la propriété DoWorkEventArgs.Argument .

worker.RunWorkerAsync(5);

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

Vous devez toujours essayer d'utiliser un objet composite avec des types concrets (en utilisant un modèle de conception composite) plutôt qu'une liste de types d'objets. Qui se souviendrait de ce qu'est diable chacun de ces objets? Pensez à la maintenance de votre code plus tard ... Essayez plutôt quelque chose comme ceci:

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

Puis:

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

puis:

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