🗡️ 🚷 🔃 अवलोकनीय। पुनर्जीवित और सूची गणना 🏴 🤜🏽 👼🏻

प्रतिक्रियाशील एक्सटेंशन (उर्फ आरएक्स - रिएक्टिव एक्सटेंशन) के पुस्तकालय में एक सहायक विधि है । उत्पन्न करें , जो आपको सरल अवलोकन अनुक्रम उत्पन्न करने की अनुमति देता है।

IObservable<string> xs = Observable.Generate<int, string>( initialState: 0, //   condition: x => x < 10, //    iterate: x => x + 1, //   resultSelector: x => x.ToString() //      ); xs.Subscribe(x => Console.WriteLine("x: {0}", x));

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

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

 static IEnumerable<string> GenerateSequence() { for ( int x = 0; //initialState x < 10; // condition x = x + 1 // iterate ) { yield return x.ToString(); // resultSelector } } static void Main(string[] args) { var xs = GenerateSequence(); foreach (var x in xs) Console.WriteLine("x: {0}", x); }

कोड के दोनों संस्करण समतुल्य हैं, लेकिन यदि पहले मामले में एक पुश अनुक्रम बनाया जाता है ( टी इंटरफ़ेस के IObservable के रूप में), जो स्वतंत्र रूप से नए तत्वों के आगमन की सूचना देगा, तो दूसरे मामले में हमें एक पुल अनुक्रम मिलता है ( टी इंटरफ़ेस के IEnumerable के रूप में); जिसमें से आपको इन तत्वों को "सरौता" से "बाहर निकालना" चाहिए।

नोट
संक्षेप में, पुल मॉडल बाहरी दुनिया के साथ एप्लिकेशन के इंटरैक्शन का एक ऐसा मॉडल है, जब एप्लिकेशन प्रमुख भूमिका निभाता है। यदि आप IEnumerable इंटरफ़ेस को देखते हैं, तो यह कॉलिंग कोड है जो अगले जाने के लिए MoveNext विधि को कॉल करके तत्व के प्रवाह को नियंत्रित करता है। पुश मॉडल में, क्रियाएं एक अलग तरीके से सामने आती हैं: बाहरी वातावरण स्वयं कुछ घटनाओं (उदाहरण के लिए, नए डेटा की उपस्थिति) के आवेदन को सूचित करता है, और आवेदन केवल उन्हें "प्रतिक्रिया" देता है। आप इन मॉडलों के बारे में और अधिक पढ़ सकते हैं, IEnumerable / IObservable इंटरफेस के द्वंद्ववाद , साथ ही साथ लेख में प्रतिक्रियाशील विस्तार पुस्तकालय की अन्य विशेषताएं: प्रतिक्रियाशील एक्सटेंशन और अतुल्यकालिक संचालन ।

चूंकि पुश और पुल अनुक्रमों के इंटरफेस ( टी के आईओब्जर्वेबल और क्रमशः टी के आईनुमेरेबल ) समान हैं, अनुक्रम के एक रूप से दूसरे में परिवर्तित करने का विचार आसानी से हमारे सिर पर आ सकता है:

 int[] ai = new[] {1, 2, 3}; IObservable<int> oi = Observable.Generate( /*initialState:*/ ai.GetEnumerator(), /*condition:*/ e => e.MoveNext(), /*iterate:*/ e => e, /*resultSelector:*/ e => (int)e.Current ); oi.Subscribe(i => Console.WriteLine("i: {0}", i));

सामान्य तौर पर, कुछ भी आपराधिक नहीं है, और इस कोड को निष्पादित करते समय, हम उम्मीद करते हैं:

1
2
3

लेकिन क्या होगा, अगर एक सरणी के बजाय, हम सूची के साथ भी ऐसा ही करना चाहते हैं:

 List<int> li = new List<int> {1, 2, 3}; IObservable<int> oi = Observable.Generate( /*initialState:*/ li.GetEnumerator(), /*condition:*/ e => e.MoveNext(), /*iterate:*/ e => e, /*resultSelector:*/ e => (int)e.Current ); oi.Subscribe(i => Console.WriteLine("i: {0}", i));

और, स्वाभाविक रूप से, इस मामले में हमें मिलता है ... शून्य का एक अनंत अनुक्रम।

नोट
हां, मुझे पता है कि एक सरल अनुक्रम को एक अवलोकन योग्य अनुक्रम में परिवर्तित करने का सबसे आसान तरीका अवलोकन योग्य विस्तार विधि का उपयोग करना है । ToObservable , जो IEnumerable इंटरफ़ेस का "विस्तार" करता है। लेकिन मान लीजिए कि हम या तो इसके बारे में नहीं जानते हैं, या हमें जनरेट विधि में उपलब्ध अधिक जटिल तर्क की आवश्यकता है।

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

परिवर्तनीय संरचनाएं बुराई हैं, और केवल एन्यूमरेटर्स के लिए सबसे आम उपयोग के मामले के लिए कोड को अनुकूलित करने की इच्छा ने बीसीएल डेवलपर्स को उन्हें संरचना बनाने के लिए प्रेरित किया है, न कि कक्षाएं। चूँकि C # 2.0 में प्रगणकों के लिए सबसे आम उपयोग का मामला एक फ़ॉरेस्ट लूप में इसका उपयोग करना था जो कि उत्परिवर्तनीय संरचनाओं के साथ समस्याओं से ग्रस्त नहीं था, इसलिए यह कुछ प्रोसेसर चक्रों को बचाने और प्रवर्तक के लिए एक वर्ग के बजाय एक संरचना का उपयोग करने का निर्णय लिया गया था।

नोट
यह इस तरह क्यों किया गया इस पर विवरण साशा गोल्ड्सटीन के एक पोस्ट में पाया जा सकता है , साथ ही एरिक लिपर्ट के स्टैकओवरफ्लो पर जवाब भी । परस्पर महत्वपूर्ण प्रकारों की अन्य समस्याएं लेख में पाई जा सकती हैं: परस्पर महत्वपूर्ण प्रकारों के खतरों पर ।

यह समस्या काफी सरल रूप से हल हो गई है: इसके लिए, इंटरफ़ेस में एन्यूमरेटर के प्रारंभिक मूल्य को लाने के लिए पर्याप्त है, जो इसकी पैकेजिंग और उसके बाद प्रबंधित हीप में स्थित "सामान्य" चर का संशोधन करेगा, न कि कॉपी को बदलने के लिए:

 IObservable<int> oi = Observable.Generate( /*initialState:*/ (IEnumerator<int>)li.GetEnumerator(), /*condition:*/ e => e.MoveNext(), /*iterate:*/ e => e, /*resultSelector:*/ e => (int)e.Current );

अवलोकनीय। पुनर्जीवित और सूची गणना

More articles: