tipos - metodos anonimos c#

BackgroundWorker con métodos anónimos?

Question

Voy a crear un BackgroundWorker con un método anónimo.
He escrito el siguiente código:

BackgroundWorker bgw = new BackgroundWorker();
bgw.DoWork += new DoWorkEventHandler(
() =>
{
int i = 0;
foreach (var item in query2)
{
....
....
}
}
);

Pero el delegado ''System.ComponentModel.DoWorkEventHandler'' no toma los argumentos ''0'' y tengo que pasar dos objetos al método anónimo: remitente del objeto, DoWorkEventArgs e

¿Podría por favor guiarme, cómo puedo hacerlo? Gracias.

Answer 1

Vamos a hacerlo simple

Las expresiones Lambda son realmente útiles para hacer el código más corto y más legible. Sin embargo, a los programadores de nivel de entrada les puede resultar un poco difícil tratar con ellos. Hay tres conceptos separados por los que se debe pasar: métodos anónimos, delegados y expresiones lambda. Un recorrido detallado de cada uno de ellos está fuera del alcance de esta respuesta. Espero que el ejemplo de código que se proporciona a continuación sirva para dar una vista rápida de los diferentes enfoques disponibles.

class TestBed
{
BackgroundWorker bgw = new BackgroundWorker();
void sample()
{
//approach #1
bgw.DoWork += new DoWorkEventHandler(bgw_DoWork);
//DoWorkEventHandler is nothing but a readily available delegate written by smart Microsoft guys
//approach #2, to make it a little shorter
bgw.DoWork += (s,e) =>
{
//...
};
//this is called lambda expression (see the => symbol)
//approach #3, if lambda scares you
bgw.DoWork += delegate
{
//... (but you can''t have parameters in this approach
};
//approach #4, have a helper method to prepare the background worker
prepareBgw((s,e)=>
{
//...
}
);
//approach #5, helper along with a simple delegate, but no params possible
prepareBgw(delegate
{
//...
}
);
//approach #6, helper along with passing the methodname as a delegate
prepareBgw(bgw_DoWork);
//approach #7, helper method applied on approach #1
prepareBgw(new DoWorkEventHandler(bgw_DoWork));
}
void bgw_DoWork(object sender, DoWorkEventArgs e)
{
//...
}
void prepareBgw(DoWorkEventHandler doWork)
{
bgw.DoWork+= doWork;
}
}

Tenga en cuenta que en este ejemplo usamos "delegar" y no "delegar" (hay una diferencia entre las dos)

Answer 2

Si especifica un lambda, debe asegurarse de que toma el mismo número de argumentos:

bgw.DoWork += (s, e) => ...;

Pero si no está utilizando los argumentos, podría usar un delegado anónimo sin parámetros:

bgw.DoWork += delegate
{
...
};

Answer 3

Si has escrito lo anterior sin lambdas ¿cómo sería?

backgroundWorker1.DoWork +=
new DoWorkEventHandler(backgroundWorker1_DoWork);

y el método nombrado:

private void backgroundWorker1_DoWork(object sender,
DoWorkEventArgs e)
{
// Get the BackgroundWorker that raised this event.
BackgroundWorker worker = sender as BackgroundWorker;
// Assign the result of the computation
// to the Result property of the DoWorkEventArgs
// object. This is will be available to the
// RunWorkerCompleted eventhandler.
e.Result = ComputeFibonacci((int)e.Argument, worker, e);
}

Pero ahora está utilizando lambdas sin variables enlazadas () => Debe proporcionar dos objetos remitente y e (que se deducirán del tipo más adelante).

backgroundWorker1.DoWork += (sender, e) => ...

Answer 4

Solo necesita agregar parámetros a la función anónima:

bgw.DoWork += (sender, e) => { ... }

O si no te importan los parámetros puedes simplemente:

bgw.DoWork += delegate { ... }