BackgroundWorker con metodi anonimi?

Question

Creerò un BackgroundWorker con un metodo anonimo.
Ho scritto il seguente codice:

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

Ma delegato 'System.ComponentModel.DoWorkEventHandler' non tiene '0' argomenti e devo passare due oggetti al metodo anonimo: mittente dell'oggetto, DoWorkEventArgs e

Coul tu per favore guidami, come posso farlo? Grazie.

Answer 1

Hai solo bisogno di aggiungere parametri alla funzione anonima:

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

O se non si preoccupano i parametri che è possibile solo:

bgw.DoWork += delegate { ... } 

Answer 2

se si specifica un lambda, è deve garantire che prende lo stesso numero di argomenti:

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

Ma se non si sta usando gli argomenti, si potrebbe jus t utilizzare un delegato anonimo senza parametri:

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

Answer 3

Se hai scritto quanto sopra senza lambda come sarebbe?

backgroundWorker1.DoWork += 
       new DoWorkEventHandler(backgroundWorker1_DoWork); 

ed il metodo denominato:

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

Ma ora si sta utilizzando lambda senza variabili vincolate() => È necessario fornire due oggetti mittente e posta (che otterranno tipo inferito tardi).

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

Answer 4

Lets rendere semplice

lambda espressioni sono davvero a portata di mano per rendere il codice più breve e più leggibile. Tuttavia, i programmatori entry-level potrebbero trovarlo un po 'difficile da gestire. Ci sono tre concetti separati da seguire: metodi anonimi, delegati e espressioni lambda. Una dettagliata descrizione di ognuno di essi va oltre lo scopo di questa risposta. Spero che l'esempio di codice fornito di seguito serva allo scopo di dare una rapida visione dei diversi approcci disponibili.

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

Nota che abbiamo usato "delegato" e non "delegato" in questo esempio (c'è una differenza tra i due)