पृष्ठभूमिवर्कर?

Question

मैं एक अज्ञात विधि के साथ पृष्ठभूमिवर्कर बनाने वाला हूं।
मैं निम्नलिखित कोड लिखा है:

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

लेकिन प्रतिनिधि 'System.ComponentModel.DoWorkEventHandler' नहीं ले करता है '0' तर्क और मैं दो पारित करने के लिए है अज्ञात विधि के लिए ऑब्जेक्ट्स: ऑब्जेक्ट प्रेषक, DoWorkEventArgs e

Coul क्या आप कृपया मुझे मार्गदर्शन करें, मैं इसे कैसे कर सकता हूं? धन्यवाद। या

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

यदि आप पैरामीटर के बारे में परवाह नहीं है तुम सिर्फ कर सकते हैं:

Answer 1

तुम बस गुमनाम कार्य करने के लिए पैरामीटर जोड़ने होंगे

bgw.DoWork += delegate { ... } 

Answer 2

आप एक लैम्ब्डा आप निर्दिष्ट करते हैं, यह सुनिश्चित करना चाहिए कि यह तर्कों की एक ही संख्या लेता है:

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

लेकिन यदि आप तर्कों का उपयोग नहीं कर रहे हैं, तो आप जा सकते हैं पैरामीटर के बिना एक अज्ञात प्रतिनिधि का उपयोग नहीं करें:

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

Answer 3

यदि आपने उपरोक्त लिखा है तो यह कैसे होगा?

backgroundWorker1.DoWork += 
       new DoWorkEventHandler(backgroundWorker1_DoWork); 

और नामित विधि:

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

लेकिन अब आप कोई बाध्य चर के साथ lambdas उपयोग कर रहे हैं() => आप दो वस्तुओं प्रेषक और ई (जो वे प्रकार बाद में लगाए गए अनुमान हो जाएगा प्रदान करना चाहिए)।

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

Answer 4

कर इसे सरल

लैम्ब्डा भाव वास्तव में कोड छोटे और अधिक पठनीय बनाने के लिए काम कर रहे हैं देता है। हालांकि प्रवेश स्तर प्रोग्रामर को इससे निपटने में थोड़ा मुश्किल लग सकता है। तीन अलग-अलग अवधारणाएं हैं जिनके माध्यम से जाना चाहिए: अनाम विधियां, प्रतिनिधि और लैम्ब्डा अभिव्यक्तियां। उनमें से प्रत्येक का विस्तृत चलना इस उत्तर के दायरे से बाहर है। मुझे आशा है कि नीचे दिया गया कोड उदाहरण उपलब्ध विभिन्न दृष्टिकोणों का त्वरित दृश्य देने के उद्देश्य से कार्य करेगा।

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

ध्यान दें कि हम इस उदाहरण में "प्रतिनिधि" और नहीं "प्रतिनिधि" का इस्तेमाल किया