parameter - default value method c#

¿Enviar 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 debería tomar un parámetro int.

Answer 1

Aunque esta es una pregunta ya respondida, dejaría otra opción que IMO 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 del controlador:

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

Answer 2

Consulte la propiedad 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;
}
}

Answer 3

Necesita el 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 4

Puede pasar múltiples 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.
}

Answer 5

Puede usar la propiedad DoWorkEventArgs.Argument .

Un ejemplo completo (incluso usando un argumento int) se puede encontrar en el sitio de Microsoft:

• Cómo: ejecutar una operación en segundo plano

Answer 6

Puedes probar esto si quieres pasar más de un tipo de argumentos, primero agrégalos a una matriz de tipo Object y pasa ese objeto a RunWorkerAsync (). Aquí hay un ejemplo:

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

Ahora en el método doWork de trabajador de fondo

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

Answer 7

Siempre debe intentar usar un objeto compuesto con tipos concretos (utilizando un patrón de diseño compuesto) en lugar de una lista de tipos de objetos. ¿Quién recordaría qué diablos es cada uno de esos objetos? Piense en el mantenimiento de su código más tarde ... En su lugar, intente algo como esto:

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

Y entonces:

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

y entonces:

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

Answer 8

Usted comienza de esta manera:

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

y entonces

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