थ्रेडिंग और लैम्ब्डा एक्सप्रेशन

Question

नीचे दिए गए कोड के दो टुकड़ों के बीच क्या अंतर है? क्या दूसरे का उपयोग करने में कोई समस्या होगी?

परिदृश्य 1:

private void Log(Exception e) 
{ 
    ThreadPool.QueueUserWorkItem(new WaitCallback(Log), e); 
} 

private void Log(object obj) 
{ 
    Exception e = (Exception)obj; 
    Logger.Log(e); 
} 

परिदृश्य 2

private void Log(Exception e) 
{ 
    ThreadPool.QueueUserWorkItem(
     (obj) => 
      { 
       Logger.Log(e); 
      }); 
} 

परिदृश्य 2 में, मैं ThreadPool करने के लिए एक पैरामीटर के रूप में में अपवाद गुजर नहीं कर रहा हूँ। अपवाद वस्तु का धागा marshalling कैसे होता है? क्या कोई समस्या होगी? अगर ऐसा करने की सीमाएं क्या हैं? बड़ा फायदा यह है कि आप किसी भी पैरामीटर में आसानी से पास कर सकते हैं।

Answer 1

एकमात्र अंतर यह है कि परिदृश्य में आप e चर पर बंद कर रहे हैं जो प्रभावी रूप से ढेर परिवर्तनीय e को एक कस्टम प्रकार में ले जाता है जो ढेर में स्थानांतरित हो जाता है ताकि आप इसे खो न सकें।

मुझे लगता है कि यह ठीक काम करना चाहिए।

संपादित करें: प्रदर्शन के लिए, दो परिदृश्यों के बीच कोई महत्वपूर्ण अंतर नहीं होना चाहिए। परिदृश्य 1 में आप state को QueueUserWorkItem विधि में अपवाद पास कर रहे हैं जो आंतरिक रूप से उस अपवाद संदर्भ को ढेर पर ले जाता है। एकमात्र ओवरहेड यह है कि जब आप बंद करने का उपयोग करते हैं तो यह है कि संकलक आपके लिए एक प्रकार बनाता है और उस प्रकार के फ़ील्ड के रूप में किसी भी कैप्चर किए गए चर को स्टोर करता है।

Answer 2

बस ध्यान दें, लैम्ब्डा के बजाय, आप एक गुमनाम विधि के साथ भी ऐसा ही हो सकता है, और यह भी सी # 2.0 में काम करेगा:

ThreadPool.QueueUserWorkItem(delegate(Object e) 
    { 
     Logger.Log(e as Exception); 
    });