¿Enviando argumentos al trabajador de fondo?

Question

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

private void worker_DoWork(object sender, DoWorkEventArgs e) { 

} 

sé cuando esto es worker.RunWorkerAsync() ;, no entiendo cómo definir en worker_DoWork que debe tomar un parámetro int.

Answer 1

Se empieza así:

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

y luego

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

Answer 2

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

worker.RunWorkerAsync(5); 

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

Answer 3

Puede usar la propiedad DoWorkEventArgs.Argument.

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

• How to: Run an Operation in the Background

Answer 4

Mira la DoWorkEventArgs.Argument Property:

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

Answer 5

A pesar de que esta es una pregunta ya contestada, que dejaría otra opción que la OMI 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 de controlador :

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

Answer 6

Puede pasar varios 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. 

}