पृष्ठभूमिवर्कर के लिए वैकल्पिक जो एक से अधिक तर्क स्वीकार करता है?

Question

पृष्ठभूमिवर्कर ऑब्जेक्ट हमें DoWorkEventHandler में एक भी तर्क पारित करने की अनुमति देता है।

// setup/init: 
BackgroundWorker endCallWorker = new BackgroundWorker(); 
endCallWorker.DoWork += new DoWorkEventHandler(EndCallWorker_DoWork); 
... 
endCallWorker.RunWorkerAsync(userName); 

// the handler: 
private void EndCallWorker_DoWork(object sender, DoWorkEventArgs e) 
{ 
    string userName = e.Argument as string; 
    ... 
} 

कई तर्क पारित करने के लिए, मैं, एक वस्तु में उन्हें लपेटो चाहिए इस गरीब स्ट्रिंग सरणी की तरह:

// setup/init: 

BackgroundWorker startCallWorker = new BackgroundWorker(); 
startCallWorker.DoWork += new DoWorkEventHandler(StartCallWorker_DoWork); 
... 
startCallWorker.RunWorkerAsync(new string[]{userName, targetNumber}); 


// the handler: 
private void StartCallWorker_DoWork(object sender, DoWorkEventArgs e) 
{ 
    string[] args = e.Argument as string[]; 
    string userName = args[0]; 
    string targetNumber = args[1]; 
} 

वहाँ किसी अन्य वस्तु या पैटर्न हमें कई तर्क अच्छी तरह से, या आदर्श पारित की अनुमति देता है, अपना हस्ताक्षर लिखें?

Answer 1

आप एक बंद (लैम्ब्डा) इस्तेमाल कर सकते हैं:

backgroundWorker.DoWork += (s, e) => MyWorkMethod(userName, targetNumber); 

या साथ प्रतिनिधि (अनाम विधि) वाक्य रचना:

backgroundWorker.DoWork += 
    delegate(object sender, DoWorkEventArgs e) 
    { 
     MyWorkMethod(userName, targetNumber); 
    }; 

Answer 2

क्यों "एक" ऑब्जेक्ट पैरामीटर की सरणी नहीं है? आपको ऑब्जेक्ट पैरामीटर से विधि के अंदर इसे सरणी में वापस डालना होगा।

Answer 3

हो सकता है कि अपने उद्देश्य के रूप में एक लैम्ब्डा समारोह पारित? फिर आप इसे DoWork हैंडलर में कॉल करेंगे।

endCallWorker.RunWorkerAsync(new Action(() => DelegatedCallTarget(userName, targetNumber))); 

Answer 4

ऑब्जेक्ट एक सूची या सरणी या कुछ ऐसा हो सकता है। बस अपनी ऑब्जेक्ट को किसी प्रकार का कंटेनर बनाएं, फिर BackgroundWorker में डालें। आपको यह सुनिश्चित करने की ज़रूरत है कि आप हमेशा एक ही प्रकार में गुज़र रहे हैं।

Answer 5

टाइप किए गए ऑब्जेक्ट का उपयोग करने में क्या गड़बड़ है?

internal class UserArgs 
{ 
    internal string UserName { get; set; } 
    internal string TargetNumber { get; set; } 
} 

var args = new UserArgs() {UserName="Me", TargetNumber="123" }; 
startCallWorker.RunWorkerAsync(args); 

Answer 6

टाइप किए गए ऑब्जेक्ट के बजाय। सी # 4.0 हमें ट्यूपल प्रदान करता है। हम एकाधिक तर्क रखने के लिए एक tuple का उपयोग कर सकते हैं। फिर एक नई कक्षा घोषित करने की कोई आवश्यकता नहीं है।

Answer 7

एक वर्ग है कि आप यह कैसे काम करता है पर विस्तृत सकता है आपके सभी तर्कों

Class MyClass 
{ 
    private string m_Username = string.Empty; 
    private int m_Targetnumber; 

    public MyClass(){} 

    public string Username 
    { 
     get { return m_Username; } 
     set { m_Username = value; } 
    } 

    public int TargetNumber 
    { 
     get { return m_TargetNumber; } 
     set { m_TargetNumber = value; } 
    } 
} 



// setup/init: 

BackgroundWorker startCallWorker = new BackgroundWorker(); 
startCallWorker.DoWork += new DoWorkEventHandler(StartCallWorker_DoWork); 
... 

MyClass thisClass = new MyClass(); 
thisClass.Username = "abcd"; 
thisClass.TargetNumber = 1234; 
startCallWorker.RunWorkerAsync(thisClass); 


// the handler: 
private void StartCallWorker_DoWork(object sender, DoWorkEventArgs e) 
{ 
    MyClass args = (MyClass)e.Argument; 
    string userName = args.Username; 
    string targetNumber = args.TargetNumber; 
}