Argumente an Hintergrundarbeiter senden?

Angenommen, ich möchte einen int-Parameter an einen Hintergrundarbeiter senden. Wie kann dies erreicht werden?

private void worker_DoWork(object sender, DoWorkEventArgs e) {

}

Ich weiß, wann dies worker.RunWorkerAsync (); ist. Ich verstehe nicht, wie man in worker_DoWork definiert, dass es einen int-Parameter annehmen soll.

Sie starten es so:

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

und dann

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

Obwohl dies eine bereits beantwortete Frage ist, würde ich eine andere Option belassen, die IMO viel einfacher zu lesen ist:

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

Und zur Handler-Methode:

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

Sie können mehrere Argumente wie folgt übergeben.

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. 

}

Sie können die DoWorkEventArgs.ArgumentEigenschaft verwenden.

Ein vollständiges Beispiel (auch unter Verwendung eines int-Arguments) finden Sie auf der Microsoft-Website:

• Gewusst wie: Führen Sie eine Operation im Hintergrund aus

Überprüfen Sie die DoWorkEventArgs.Argument-Eigenschaft :

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

Sie können dies ausprobieren, wenn Sie mehr als einen Argumenttyp übergeben möchten. Fügen Sie zunächst alle zu einem Array vom Typ Object hinzu und übergeben Sie dieses Objekt an RunWorkerAsync (). Hier ein Beispiel:

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

Jetzt in der doWork-Methode des Hintergrundarbeiters

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

Sie benötigen die RunWorkerAsync (Objekt) -Methode und die DoWorkEventArgs.Argument- Eigenschaft.

worker.RunWorkerAsync(5);

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

Sie sollten immer versuchen, ein zusammengesetztes Objekt mit konkreten Typen (unter Verwendung eines zusammengesetzten Entwurfsmusters) anstelle einer Liste von Objekttypen zu verwenden. Wer würde sich daran erinnern, was zum Teufel jedes dieser Objekte ist? Denken Sie später über die Wartung Ihres Codes nach ... Versuchen Sie stattdessen Folgendes:

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

Und dann:

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

und dann:

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