बत्तख टाइपिंग या "प्राचीनता इतनी सरल है?"

मुझे लगता है कि कई डेवलपर्स जानते हैं कि सी # में फॉर्च्यूप लूप इतना सरल नहीं है जितना पहली नज़र में लगता है। शुरू करने के लिए, आइए इस प्रश्न का उत्तर दें: "सफलतापूर्वक निर्माण करने के लिए फॉर्च्यूनर के निर्माण में क्या लगता है?" इस सवाल का एक सहज जवाब कुछ इस तरह लगता है: "वर्ग IEnumerable या IEnumerable < T > " इंटरफ़ेस को लागू करता है। हालांकि, यह ऐसा नहीं है, ठीक है, या बिल्कुल नहीं।

इस प्रश्न का पूर्ण उत्तर है: " फॉरकच निर्माण के लिए सफलतापूर्वक संकलन करने के लिए, यह आवश्यक है कि ऑब्जेक्ट में एक गेटनेमर () विधि है, जो किसी ऑब्जेक्ट को MoveNext () विधि और वर्तमान गुण के साथ वापस कर देगा, और यदि ऐसी कोई विधि नहीं है, तो हम IEnumerable इंटरफेस की तलाश करेंगे। और IEnumerable < T > "।

इस "बतख" व्यवहार के दो कारण हैं।


आइए C # 1.0 के पुराने दिनों को याद करें, जब भाषा सरल और सीधी थी, और कोई जेनरिक, LINQ और अन्य क्लोजर नहीं थे। लेकिन चूंकि कोई जेनरिक नहीं थे, इसलिए "सामान्यीकरण" और पुन: उपयोग बहुरूपता और वस्तु प्रकार पर आधारित था, जो वास्तव में, संग्रह और उनके पुनरावृत्तियों के वर्गों में किया गया था।

ये वही पुनरावृत्तियाँ आईएननुमेरेबल और आईयूमनरेटर इंटरफेस की एक जोड़ी थीं, जबकि बाद वाले ने वर्तमान संपत्ति में एक वस्तु लौटा दी। और यदि ऐसा है, तो IEnumerator इंटरफ़ेस का उपयोग करके महत्वपूर्ण प्रकारों के जोरदार टाइप किए गए तत्वों के पुनरावृति के लिए प्रत्येक पुनरावृत्ति पर इस मान को पैकिंग और अनपैकिंग के लिए ले जाया जाएगा, जिसे आप देखते हैं, बहुत महंगा हो सकता है जब यह एन्यूमरेटिंग तत्वों जैसे सामान्य ऑपरेशन के लिए आता है।

इस समस्या को हल करने के लिए, बतख टाइपिंग के साथ एक हैक का उपयोग करने का निर्णय लिया गया था, और प्रदर्शन के लिए ओओपी के सिद्धांतों पर थोड़ा स्कोर किया गया था। इस स्थिति में, वर्ग IEnumerable इंटरफ़ेस को स्पष्ट रूप से लागू कर सकता है और एक अतिरिक्त GetEnumerator () विधि प्रदान कर सकता है जो एक दृढ़ता से टाइप किए गए एन्यूमरेटर को लौटाएगा, जिसकी वर्तमान संपत्ति एक विशिष्ट प्रकार लौटाती है , उदाहरण के लिए, बिना किसी पैकेजिंग के डेटटाइम ।

लगभग। हमने डायनासोर का पता लगाया, लेकिन वास्तविक दुनिया के बारे में क्या? वास्तव में, आंगन में, अभी भी पत्थर की उम्र नहीं है, कॉम ने पहले ही ओक दिया है, डॉन बॉक्स अब किताबें नहीं लिखते हैं, और गीक्स हमारे दरवाजे पर सभी प्रकार के कार्यात्मक उपहारों के साथ फटते हैं। क्या अब इस व्यवहार से कोई लाभ है?

आप सोच सकते हैं कि IEnumerable < T > और IEnumerator < T > इंटरफेस के सामान्यीकृत संस्करणों की उपस्थिति के बाद, बतख टाइपिंग ट्रिक की अब आवश्यकता नहीं है, लेकिन यह पूरी तरह से सच नहीं है। यदि आप संग्रह कक्षाओं को करीब से देखते हैं, जैसे कि सूची < टी > , तो आप देख सकते हैं कि यह वर्ग (बीसीएल में अन्य सभी संग्रहों की तरह) IEnumerable < T > इंटरफ़ेस को स्पष्ट रूप से (विस्फोटक रूप से) लागू करता है, जबकि एक अतिरिक्त गेटन्यूमर () विधि प्रदान करता है। :

// ! public class List<T> : IEnumerable<T> { //   List<T> //  ,  !!! public struct Enumerator : IEnumerator<T>, IDisposable { } public List<T>.Enumerator GetEnumerator() { return new Enumerator(this); } //    IEnumerator<T> IEnumerator<T>.GetEnumerator() { return GetEnumerator(); } } 

हां, यह सही है। GetEnumerator () विधि एक पुनरावृत्त उदाहरण देता है, जो एक परिवर्तनशील संरचना है (सब के बाद, पुनरावृत्त में वर्तमान सूची आइटम के लिए "सूचक" होता है)। और उत्परिवर्तनीय महत्वपूर्ण प्रकार, कई के अनुसार, .NET प्लेटफ़ॉर्म पर सबसे तेज देखा जाता है, यहां तक ​​कि अधिक अनुभवी डेवलपर्स के पैर को अपंग करने में सक्षम है।

नोट
हाँ, हाँ। मुझे पता है कि मैं पहले से ही सामान्य रूप से चर गणक और विशेष रूप से चर प्रकार के साथ अपने कानों को गुलजार कर चुका हूं, लेकिन यहां हम इस व्यवहार के कारणों का स्पष्टीकरण खोजने का प्रयास करेंगे, अन्य बातों के अलावा। तो इसके साथ थोड़ा और सहन करें :)

बात यह है कि फ़ॉरेस्ट लूप की "बतख" प्रकृति के साथ मिलकर एक इट्रेटर के रूप में संरचना का उपयोग करते हुए इस निर्माण का उपयोग करते समय ढेर पर मेमोरी आवंटन को रोकता है:

 var list = new List<int> {1, 2, 3}; //  List<T>.Enumerator GetEnumerator foreach(var i in list) {} //  IEnumerable<T> GetEnumerator foreach(var i in (IEnumerable<int>)list) {} 

पहले उदाहरण में, "बत्तख" प्रकृति के कारण, लिस्ट क्लास के GetEnumerator () विधि को कहा जाता है, जो एक महत्वपूर्ण प्रकार की एक वस्तु लौटाता है जो प्रबंधित ढेर में किसी भी अतिरिक्त मेमोरी आवंटन के बिना स्टैक पर चुपचाप जीवित रहेगा। दूसरे मामले में, हम इंटरफ़ेस को चर सूची देते हैं, जो इंटरफ़ेस विधि को कॉल करेगा और तदनुसार, पुनरावृत्ति पैकेजिंग। हां, C # डेवलपर्स ने दक्षता में सुधार के लिए बहुरूपता और कई अन्य ओओपी सिद्धांतों को रखा है।

var सूची = नई सूची {1, 2, 3};

 var x1 = new { Items = ((IEnumerable<int>)list).GetEnumerator() }; while (x1.Items.MoveNext()) { Console.WriteLine(x1.Items.Current); } Console.ReadLine(); var x2 = new { Items = list.GetEnumerator() }; while (x2.Items.MoveNext()) { Console.WriteLine(x2.Items.Current); } 

यह इस कारण से है कि पहला लूप अपेक्षित 1, 2, 3 और दूसरा जबकि लूप आउटपुट करेगा ... ठीक है, इसे अपने बारे में देखें।

इस तरह के एक समाधान (एक उत्परिवर्तनीय संरचना का उपयोग करना) सूक्ष्म अनुकूलन पर लगता है, लेकिन यह मत भूलो कि फॉरेस्ट लूप को घोंसले में डाला जा सकता है, और यह कि हर कोई गीगाबाइट मेमोरी के साथ मल्टी-कोर प्रोसेसर पर काम नहीं करता है। यह निर्णय लेने से पहले, BCL टीम ने कुछ गंभीर शोध किए जिससे पता चला कि संरचनाओं का उपयोग करना वास्तव में इसके लायक था।

नोट
बस अपने स्वयं के पुनरावृत्तियों या अन्य सहायक वर्गों को लागू करते समय इस उदाहरण का तुरंत उपयोग न करें। संरचनाओं का उपयोग करना अपने आप में एक अनुकूलन है, लेकिन उत्परिवर्तनीय संरचनाओं का उपयोग करना एक गंभीर निर्णय है, इसलिए आपको उन लाभों के बारे में बहुत स्पष्ट होना चाहिए जो आपको मिलते हैं कि आप सुरक्षा का बलिदान करने के लिए तैयार हैं।

एक छोटा जोड़: डिस्पोजल कॉल का उद्देश्य क्या है ?

फ़ॉरेस्ट लूप कार्यान्वयन की एक और विशेषता यह है कि इसे पुनरावृत्ति की डिस्पोज़ विधि कहा जाता है। निम्नलिखित कोड का एक सरलीकृत संस्करण है जो कंपाइलर द्वारा जनरेट किया जाता है जब फ़ॉरच लूप में सूची चर पर पुनरावृति होती है:

 { var enumerator = list.GetEnumerator(); try { while(enumerator.MoveNext()) { int current = enumerator.Current; Console.WriteLine(current); } } finally { enumerator.Dispose(); } } 

एक वाजिब सवाल यह हो सकता है कि पुनरावृत्‍ति में प्रबंधित संसाधन कहां से आ सकते हैं? ठीक है, हां, जब मेमोरी में एक संग्रह के माध्यम से छंटनी की जाती है, तो वास्तव में उनके पास कोई जगह नहीं है जहां से आना है, लेकिन यह मत भूलो कि सी # में प्रगणकों का उपयोग केवल मेमोरी में संग्रह के लिए पुनरावृत्तियों के रूप में नहीं किया जा सकता है; कोई भी हमें एक पुनरावृत्त के साथ परेशान नहीं करता है जो लाइन द्वारा फ़ाइल लाइन की सामग्री लौटाता है:

 public static class FileEx { public static IEnumerable<string> ReadByLine(string path) { if (path == null) throw new ArgumentNullException("path"); return ReadByLineImpl(path); } private static IEnumerable<string> ReadByLineImpl(string path) { using (var sr = new StreamReader(path)) { string s; while ((s = sr.ReadLine()) != null) yield return s; } } } foreach(var line in FileEx.ReadByLine("D:\\1.txt")) { Console.WriteLine(line); } 

तो, हमारे पास रीडबाइन विधि है जिसमें हम फ़ाइल को खोलते हैं, जो निश्चित रूप से एक संसाधन है और कब बंद होता है ... कब? जाहिर है, हर बार ReadByLineImpl विधि नियंत्रण नहीं छोड़ती है, क्योंकि तब मैं इसे कई बार बंद कर दूंगा क्योंकि इस फ़ाइल में लाइनें हैं।
वास्तव में, फ़ाइल को एक बार बंद कर दिया जाएगा, ठीक उसी तरह जब इट्रेटर की डिस्पोज़ विधि को कॉल किया जाएगा, जो कि फ़ॉरच लूप के अंत में होता है। यह .NET प्लेटफॉर्म पर उन दुर्लभ मामलों में से एक है जब अंत में ब्लॉक को स्वचालित रूप से नहीं कहा जाता है, लेकिन विशेष रूप से हैंडल द्वारा कहा जाता है। इसलिए यदि आप अचानक कुछ अनुक्रम पर मैन्युअल रूप से पुनरावृति करते हैं, तो आपको यह नहीं भूलना चाहिए कि पुनरावृत्त में अभी भी संसाधन शामिल हो सकते हैं, और उन्हें स्पष्ट रूप से इट्रेटर की डिस्पोज विधि को कॉल करके बहुत अच्छा होगा।

नोट
आप एक नोट में C # में पुनरावृत्तियों के बारे में अधिक पढ़ सकते हैं ... C # में Iterators।

ZY और जो तुरंत इस सवाल का जवाब दे सकता है: मुझे रीडबाइन और रीडबाइनइम्प्ल , दो तरीकों की आवश्यकता क्यों है, मैं केवल एक ही विधि का उपयोग क्यों नहीं करता हूं?

ZYY वैसे, foreach block C # में बतख टाइपिंग के एकमात्र उदाहरण से बहुत दूर है, लेकिन आप और कितने उदाहरणों को याद कर सकते हैं?