👦🏼 🚓 👜 C # 5 में लूप वेरिएबल्स पर क्लोजर 🌡️ ➿ 👩🏼‍🌾

प्रोग्रामिंग भाषाओं, पुस्तकालयों और सरल अनुप्रयोग वर्गों के कई डेवलपर्स निर्मित कक्षाओं के लिए एक सहज ज्ञान युक्त अंतरफलक के लिए प्रयास करते हैं। स्कॉट मेयर्स ने डेढ़ दशक पहले कहा था कि हमें कक्षाओं (पुस्तकालयों, भाषाओं) को विकसित करने का प्रयास करना चाहिए जो सही तरीके से उपयोग करना आसान है और गलत तरीके से उपयोग करना मुश्किल है।

यदि हम C # भाषा के बारे में बात करते हैं, तो इसके डेवलपर्स "प्रयोज्य" के मुद्दों पर बहुत अच्छी तरह से संपर्क करते हैं; वे सामान्य ज्ञान और उपयोग में आसानी के लिए आसानी से "वस्तु शुद्धता" का त्याग कर सकते हैं। इस नियम के कुछ अपवादों में से एक समान फीचर के लूप वैरिएबल पर बंद होना है जो कई डेवलपर्स के विश्वास से अलग व्यवहार करता है। इसी समय, असंतोष और गलतफहमी की मात्रा इतनी अधिक है कि सी # भाषा के 5 वें संस्करण में उन्होंने इस व्यवहार को बदलने का फैसला किया।

तो, आइए एक उदाहरण कोड देखें जो लूप वेरिएबल को लूप करने की समस्या को दर्शाता है:

var actions = new List<Action>(); foreach(var i in Enumerable.Range(1, 3)) { actions.Add(() => Console.WriteLine(i)); } foreach(var action in actions) { action(); }

अधिकांश डेवलपर्स यथोचित मानते हैं कि इस कोड का परिणाम "1 2 3" होगा, क्योंकि लूप के प्रत्येक पुनरावृत्ति में हम उस सूची में एक अनाम विधि जोड़ते हैं जो नया मान प्रदर्शित करता है। हालाँकि, अगर हम VS2008 या VS2010 में कोड के इस टुकड़े को चलाते हैं, तो हमें "3 3 3" मिलता है। यह समस्या इतनी विशिष्ट है कि कुछ उपकरण, उदाहरण के लिए, ReSharper, कार्रवाई लाइन में एक चेतावनी देते हैं । जोड़ें () कि हम एक परिवर्तनशील चर पर कब्जा करते हैं, और एरिक लिपर्ट हर किसी को जवाब देने के लिए इतना बीमार था कि यह एक विशेषता थी, बग नहीं, कि उसने मौजूदा व्यवहार को C # 5.0 में बदलने का फैसला किया।

यह समझने के लिए कि यह कोड इस तरह से क्यों व्यवहार करता है और अन्यथा नहीं, आइए देखें कि कंपाइलर इस कोड को किस रूप में देखता है (मैं अधिक विवरण के लिए C # में कैसे काम करता है, इसके विवरण में बहुत गहराई तक नहीं जाता, "Closures in C #" देखें। ”” ।

C # में, बाहरी चर का कैप्चर "संदर्भ द्वारा" किया जाता है, और हमारे मामले में इसका मतलब है कि चर मैं स्टैक से गायब हो जाता है और एक विशेष रूप से उत्पन्न वर्ग का एक क्षेत्र बन जाता है, जिसमें अनाम विधि का शरीर भी रखा जाता है:

 //   - class Closure { public int i; public void Action() { Console.WriteLine(i); } } var actions = new List<Action>(); using (var enumerator = Enumerable.Range(1, 3).GetEnumerator()) { // int current; //     var closure = new Closure(); while(enumerator.MoveNext()) { // current = enumerator.Current; //        foreach closure.i = enumerator.Current; var action = new Action(closure.Action); actions.Add(action); } } foreach (var action in actions) { action(); }

चूंकि लूप के अंदर एक सिंगल क्लोजर ऑब्जेक्ट का उपयोग किया जाता है, फिर पहले लूप के पूरा होने के बाद, बंद करें । मैं 3 के बराबर होगा, और चूंकि क्रिया चर में एक ही बंद वस्तु के तीन संदर्भ होते हैं, इसलिए यह आश्चर्यजनक नहीं है कि अगली बार जब आप बंद करने के तरीके कहते हैं । कार्रवाई () हमें स्क्रीन पर मिलती है "3 3 3"।

C # 5.0 में परिवर्तन

C # 5.0 भाषा में परिवर्तन के रूप में बंद होने की चिंता नहीं है, और हम, जैसा कि हमने खुद को चर में बंद कर दिया है (और मूल्यों की प्रतियां नहीं बनाते हैं), इसलिए हम बंद हो जाते हैं। वास्तव में, परिवर्तन जो फॉरेस्ट लूप को प्रकट करता है, उससे संबंधित है। C # में क्लोजर को इस तरह से लागू किया जाता है कि प्रत्येक स्कोप जिसमें कैप्चर किए गए वैरिएबल होते हैं, क्लोजर क्लास का अपना उदाहरण बनता है। इसीलिए, C # के पिछले संस्करणों में वांछित व्यवहार प्राप्त करने के लिए, यह निम्नलिखित लिखने के लिए पर्याप्त था:

 var actions = new List<Action>(); foreach(var i in Enumerable.Range(1, 3)) { var tmp = i; actions.Add(() => Console.WriteLine(tmp)); }

अगर हम क्लोजर क्लास के साथ अपने सरलीकृत उदाहरण पर लौटते हैं, तो यह परिवर्तन इस तथ्य की ओर जाता है कि लूप के अंदर एक नया क्लोजर इंस्टेंस का निर्माण होता है, जो चर के वांछित मूल्य के संरक्षण की ओर जाता है:

 using (var enumerator = Enumerable.Range(1, 3).GetEnumerator()) { int current; while(enumerator.MoveNext()) { current = enumerator.Current; //        //   Closure    i var closure = new Closure {i = current}; var action = new Action(closure.Action); actions.Add(action); } }

सी # 5.0 में, उन्होंने फ़ॉरच लूप को बदलने का फैसला किया ताकि लूप के प्रत्येक पुनरावृत्ति पर, चर I को फिर से बनाया गया। वास्तव में, foreach लूप में C # के पिछले संस्करणों में केवल एक लूप वैरिएबल था, और C # 5.0 के साथ शुरू होकर, प्रत्येक पुनरावृत्ति के लिए एक नया वैरिएबल का उपयोग किया जाता है।

अब मूल फॉर्च लूप अलग तरीके से सामने आता है:

 using (var enumerator = Enumerable.Range(1, 3).GetEnumerator()) { //  C# 3.0  4.0 current   //int current; while (enumerator.MoveNext()) { //  C# 5.0 current      var current = enumerator.Current; actions.Add(() => Console.WriteLine(current)); } }

यह फ़ॉरेस्ट लूप के अंदर अस्थायी रूप से परिवर्तनशील बनाता है (क्योंकि कंपाइलर ने इसे हमारे लिए जोड़ा है), और जब हम इस कोड को चलाते हैं, तो हमें अपेक्षित "1 2 3" मिलता है।

वैसे, ध्यान दें कि यह परिवर्तन केवल फॉर्च लूप को प्रभावित करता है, जबकि लूप के व्यवहार में किसी भी तरह से बदलाव नहीं हुआ है, और जब आप लूप वेरिएबल को कैप्चर करते हैं, तब भी आपको प्रत्येक पुनरावृत्ति के भीतर एक अस्थायी वैरिएबल स्वयं बनाने की आवश्यकता होती है।

C # 5 में लूप वेरिएबल्स पर क्लोजर

C # 5.0 में परिवर्तन

संबंधित लिंक

More articles: