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 Delegado 'System.ComponentModel.DoWorkEventHandler' no tomar argumentos '0' y tengo que pasar dos Objetos al método anónimo: remitente del objeto, DoWorkEventArgs e

Coul d por favor guíame, ¿cómo puedo hacerlo? Gracias.

Answer 1

Usted sólo tiene que añadir parámetros a la función anónima:

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

O si no se preocupan por los parámetros que puede simplemente:

bgw.DoWork += delegate { ... } 

Answer 2

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

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

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

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

Answer 3

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

backgroundWorker1.DoWork += 
       new DoWorkEventHandler(backgroundWorker1_DoWork); 

y el método llamado:

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 ligadas() => Debe proporcionar dos objetos remitente y la dirección (que van a obtener el tipo inferido tarde)

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

Answer 4

Permite hacer que sea sencillo

expresiones lambda son realmente útil para hacer el código más corto y más fácil de leer. Sin embargo, los programadores de nivel de entrada pueden encontrarlo un poco difícil de tratar. Hay tres conceptos separados que uno debería atravesar: métodos anónimos, delegados y expresiones lambda. Un recorrido detallado de cada uno de ellos está más allá del alcance de esta respuesta. Espero que el ejemplo de código que se proporciona a continuación sirva para dar una visión 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 hemos utilizado "delegado" y no "delegado" en este ejemplo (hay una diferencia entre los dos) @Jader