c# - work - Enviando argumentos para o trabalhador de plano de fundo?




windows forms c# backgroundworker (6)

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

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 deveria ter um parâmetro int.


Embora essa seja uma pergunta já respondida, deixaria outra opção que o 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ê 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 de que diabos cada um desses objetos é? Pense na manutenção do seu código mais tarde ... Em vez disso, tente algo assim:

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

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 tentar fazer isso se quiser passar mais de um tipo de argumento, primeiro adicione-os 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 do trabalhador 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......
        //.....
       }




backgroundworker