सी #: एक समारोह कॉल को अवरुद्ध करने तक की स्थिति उत्पन्न होने

Question

मैं एक सी # Winforms आवेदन के विकास कर रहा हूँ, आवेदन के हिस्से के एक वेबसर्वर AsyncUpload उपयोग करने के लिए फ़ाइलों को अपलोड किया जाएगा (इसे का उपयोग, एक porgress कॉलबैक उपयोग करने की आवश्यकता के कारण), में सी # कार्यक्रम

मैं पाश अपलोड कर रहा है समारोह

for(int i=0;i < 10 ; i++) 
{ 
    Uploadfun(); 
} 

कॉल के लिए एक सरल हो गया और मज़ा कुछ जादू करता है:

Uploadfun() 
    { 
    // Logic comes here 

    // webClient.UploadFileAsync runs a 2nd thread to perform upload .. 
    webClient.UploadFileAsync(uri, "PUT", fileNameOnHD); 

} 

और एक कॉलबैक डब्ल्यू कहा जाता हो जाता है कि मुर्गी Async अपलोड

Upload_Completed_callback() 
{ 
    //Callback event 
} 

किया जाता है संपादित

तर्क अनुक्रम:

1. मज़ा बुलाया जाता है (पाश से)
2. मज़ा तर्क निष्पादित और किया जाता है ..
3. पाश
4. कॉलबैक eventuall बुलाया जाएगा के लिए वापस चला जाता है y, जब UploadFileAsync (जो एक और धागा में कुछ तर्क चल रहा है) खत्म हो जाएगा

समस्या 3 बिंदु, जब निष्पादन पाश के लिए वापस करने के लिए ले जाता है, मैं जब तक जारी रखने से पाश ब्लॉक करने की आवश्यकता पर है कॉलबैक बुलाया जाता है।

Answer 1

तो अगर मैं सही ढंग से समझ, आप कॉल करना UploadFileAsync तब तक async कॉल अपने कॉलबैक को प्रभावित किया है ब्लॉक करना चाहते हैं। यदि हां, तो मैं प्रयोग करेंगे AutoResetEvent यानी

private readonly AutoResetEvent _signal = new AutoResetEvent(false); 

fun() 
    { 
    // Logic comes here 

    // runs a 2nd thread to perform upload .. calling "callback()" when done 
    webClient.UploadFileAsync(uri, "PUT", fileNameOnHD); 

    _signal.WaitOne(); // wait for the async call to complete and hit the callback  
} 



callback() 
{ 
    //Callback event 
    _signal.Set(); // signal that the async upload completed 
} 

का उपयोग AutoResetEvent का मतलब हो जाता है कि राज्य के बाद स्वचालित रूप Set बुलाया गया है और प्रतीक्षा धागा WaitOne

Answer 2

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

आप कॉलबैक अंदर से fun कॉल कर सकते हैं। इन पंक्तियों (छद्म कोड) के साथ कुछ:

int n; 

callFunTenTimes() 
{ 
    n = 0; 
    fun(n); 
} 

callback() 
{ 
    ++n; 
    if (n < 10) 
     fun(n); 
    else 
     print("done"); 
} 

यह continuation passing style के समान है।

इस विधि का एक लाभ यह है कि आप कोई अतिरिक्त थ्रेड, ताले या अतिरिक्त तर्क जोड़ने के बिना अपनी विधि को अतुल्यकालिक बना सकते हैं - आप केवल एक कॉलबैक फ़ंक्शन प्रदान करते हैं जिसका आपका ग्राहक सब्सक्राइब कर सकता है। यह एक घटना संचालित पर्यावरण में अच्छी तरह से काम करता है।

Answer 3

समस्या

के माध्यम से संकेत प्राप्त रीसेट यहाँ है:

for(int i=0;i < 10 ; i++) 
{ 
    fun(); <-- if we block until this function finishes here, we stop the UI thread 
} 

तुम क्या कर रहे हैं अनुक्रमिक है।और तुम, यूआई धागा ब्लॉक यूआई धागा बंद लूप स्थानांतरित करने के लिए खर्च नहीं उठा सकते हैं:

volatile downloadComplete; 

void DownloadUpdates() 
{ 
    ThreadPool.QueueUserWorkItem(state => 
     for(int i = 0; i < 10; i++) 
     { 
      downloadComplete = false; 
      webClient.UploadFileAsync(uri, "PUT", fileNameOnHD); 
      while(!downloadComplete) { Thread.Sleep(1); } 
     }); 
} 

Upload_Completed_callback() 
{ 
    downloadComplete = true; 
} 

अब आप अपने यूआई धागा रोकने के बिना पाश के निष्पादन ब्लॉक कर सकते हैं, और आप भी का लाभ मिलेगा वेब क्लाइंट कक्षा से प्रगति संकेतक।

Answer 4

ज़ेब्राबॉक्स को वेटहैंडल का उपयोग करने का अधिकार है। जबकि जूलियट का समाधान काम करता है, स्पिन-प्रतीक्षा करने वाला धागा वेटहैंडल के अनुपात में प्रोसेसर की एक बड़ी मात्रा का उपभोग करेगा, जो अनिवार्य रूप से निष्क्रिय बैठेगा।