C # 8 में एसिंक्रोनस स्ट्रीम

उपयोगकर्ता इंटरफ़ेस जवाबदेही और संसाधनों तक वेब पहुंच में सुधार के लिए Async / Await कार्यक्षमता C # 5 में पेश की गई थी। दूसरे शब्दों में, अतुल्यकालिक तरीके डेवलपर्स को अतुल्यकालिक संचालन करने में मदद करते हैं जो थ्रेड्स को ब्लॉक नहीं करते हैं और एकल स्केलर परिणाम लौटाते हैं। Microsoft द्वारा अतुल्यकालिक कार्यों को सरल बनाने के कई प्रयासों के बाद, async / प्रतीक्षा टेम्पलेट ने एक सरल दृष्टिकोण के लिए डेवलपर्स के बीच एक अच्छी प्रतिष्ठा प्राप्त की है।

मौजूदा अतुल्यकालिक तरीके काफी सीमित हैं कि उन्हें केवल एक मूल्य वापस करना चाहिए। आइए कुछ async Task<int> DoAnythingAsync() विधि जो इस तरह के सिंटैक्स के लिए आम है। उसके कार्य का परिणाम कुछ एक अर्थ है। इस सीमा के कारण, आप इस फ़ंक्शन का उपयोग yield कीवर्ड और अतुल्यकालिक IEnumerable<int> इंटरफ़ेस (एक अतुल्यकालिक गणन का परिणाम वापस करने के लिए) के साथ नहीं कर सकते।

यदि आप async/await फ़ंक्शन और yield जोड़ते हैं, तो आप एक शक्तिशाली प्रोग्रामिंग मॉडल का उपयोग कर सकते हैं, जिसे एसिंक्रोनस डेटा पुल , या पुल आधारित एन्यूमरेशन आधारित एन्यूमरेशन या एसिंक्रोनस एसिंक्स अनुक्रम के रूप में जाना जाता है, क्योंकि इसे F # कहा जाता है।

C # 8 में एसिंक्रोनस थ्रेड्स का उपयोग करने की नई क्षमता एकल परिणाम वापस करने से जुड़ी सीमा को हटा देती है और अतुल्यकालिक विधि को कई मानों को वापस करने की अनुमति देती है। ये परिवर्तन अतुल्यकालिक टेम्पलेट को अधिक लचीलापन देंगे, और उपयोगकर्ता विलंबित अतुल्यकालिक अनुक्रमों का उपयोग करके कहीं से डेटा (उदाहरण के लिए, डेटाबेस से) प्राप्त कर सकेंगे या उपलब्ध भागों में अतुल्यकालिक अनुक्रमों से डेटा प्राप्त कर सकेंगे।

एक उदाहरण:

 foreach await (var streamChunck in asyncStreams) { Console.WriteLine($“Received data count = {streamChunck.Count}”); } 

अतुल्यकालिक प्रोग्रामिंग से संबंधित समस्याओं को हल करने के लिए एक और दृष्टिकोण प्रतिक्रियाशील एक्सटेंशन (आरएक्स) का उपयोग करना है। Rx डेवलपर्स के बीच महत्व प्राप्त कर रहा है और इस पद्धति का उपयोग कई प्रोग्रामिंग भाषाओं में किया जाता है, उदाहरण के लिए जावा (RxJava) और जावास्क्रिप्ट (RxJS)।

Rx एक पुश पुश मॉडल पर आधारित है (टेल डोन्ट आस्क सिद्धांत), जिसे प्रतिक्रियाशील प्रोग्रामिंग के रूप में भी जाना जाता है। यानी IEnumerable के विपरीत, जब उपभोक्ता Rx मॉडल में अगले तत्व का अनुरोध करता है, तो डेटा प्रदाता उपभोक्ता को संकेत देता है कि एक नया तत्व अनुक्रम में दिखाई देता है। डेटा को अतुल्यकालिक मोड में कतार में धकेल दिया जाता है और उपभोक्ता इसे रसीद के समय उपयोग करता है।

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

पुलिंग डेटा (पुल-) पर आधारित मॉडल के साथ डेटा को पुश करने पर आधारित मॉडल की तुलना

अंजीर। -1- डेटा पुशिंग पर आधारित मॉडल के साथ डेटा पुलिंग पर आधारित मॉडल की तुलना

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

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

आरएक्स और अक्का स्ट्रीम (एक प्रवाह-आधारित प्रोग्रामिंग मॉडल) प्रवाह को नियंत्रित करने के लिए पीठ के दबाव विधि का उपयोग करते हैं। आपूर्तिकर्ता और ऊपर वर्णित प्राप्तकर्ता की समस्याओं को हल करने के लिए, विधि डेटा को पुश और खींचने दोनों का उपयोग करती है।

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

उपयोग और बुनियादी जानकारी के लिए प्रेरणा

अतुल्यकालिक धागे की पूरी आवश्यकता को समझने के लिए, निम्नलिखित कोड पर विचार करें।

 //       (count) static int SumFromOneToCount(int count) { ConsoleExt.WriteLine("SumFromOneToCount called!"); var sum = 0; for (var i = 0; i <= count; i++) { sum = sum + i; } return sum; } //  : const int count = 5; ConsoleExt.WriteLine($"Starting the application with count: {count}!"); ConsoleExt.WriteLine("Classic sum starting."); ConsoleExt.WriteLine($"Classic sum result: {SumFromOneToCount(count)}"); ConsoleExt.WriteLine("Classic sum completed."); ConsoleExt.WriteLine("################################################"); ConsoleExt.WriteLine(Environment.NewLine); 

निष्कर्ष:

हम पैदावार विवरण का उपयोग करके विधि को स्थगित कर सकते हैं, जैसा कि नीचे दिखाया गया है।

 static IEnumerable<int> SumFromOneToCountYield(int count) { ConsoleExt.WriteLine("SumFromOneToCountYield called!"); var sum = 0; for (var i = 0; i <= count; i++) { sum = sum + i; yield return sum; } } 

विधि कॉल

 const int count = 5; ConsoleExt.WriteLine("Sum with yield starting."); foreach (var i in SumFromOneToCountYield(count)) { ConsoleExt.WriteLine($"Yield sum: {i}"); } ConsoleExt.WriteLine("Sum with yield completed."); ConsoleExt.WriteLine("################################################"); ConsoleExt.WriteLine(Environment.NewLine); 

निष्कर्ष:

जैसा कि ऊपर दिए गए आउटपुट विंडो में दिखाया गया है, परिणाम भागों में लौटाया जाता है, एक भी मूल्य नहीं। ऊपर दिखाए गए सारांश परिणामों को स्थगित सूची के रूप में जाना जाता है। हालाँकि, समस्या अभी भी हल नहीं हुई है: समन विधियाँ कोड को ब्लॉक करती हैं। यदि आप थ्रेड्स को देखते हैं, तो आप देख सकते हैं कि सब कुछ मुख्य धागे में चल रहा है।

आइए, पहले SumFromOneToCount तरीके (उपज के बिना) के लिए एसिंक्स मैजिक शब्द लागू करें।

 static async Task<int> SumFromOneToCountAsync(int count) { ConsoleExt.WriteLine("SumFromOneToCountAsync called!"); var result = await Task.Run(() => { var sum = 0; for (var i = 0; i <= count; i++) { sum = sum + i; } return sum; }); return result; } 

विधि कॉल

 const int count = 5; ConsoleExt.WriteLine("async example starting."); //      . ,  . ,        . var result = await SumFromOneToCountAsync(count); ConsoleExt.WriteLine("async Result: " + result); ConsoleExt.WriteLine("async completed."); ConsoleExt.WriteLine("################################################"); ConsoleExt.WriteLine(Environment.NewLine); 

निष्कर्ष:

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

आइए इसे C # के वर्तमान संस्करण में करने का प्रयास करें। मैं async कीवर्ड को SumFromOneToCountYield विधि में निम्नानुसार जोड़ूंगा:

अंजीर। -2- एक ही समय में उपज और एसिंक्स कीवर्ड का उपयोग करते समय त्रुटि।

जब हम Async को SumFromOneToCountYield में जोड़ने का प्रयास करते हैं, तो ऊपर दिखाए गए अनुसार एक त्रुटि होती है।
आइए इसे अलग तरीके से आजमाएं। हम उपज कीवर्ड को हटा सकते हैं और कार्य को निम्न में लागू कर सकते हैं, जैसा कि नीचे दिखाया गया है:

 static async Task<IEnumerable<int>> SumFromOneToCountTaskIEnumerable(int count) { ConsoleExt.WriteLine("SumFromOneToCountAsyncIEnumerable called!"); var collection = new Collection<int>(); var result = await Task.Run(() => { var sum = 0; for (var i = 0; i <= count; i++) { sum = sum + i; collection.Add(sum); } return collection; }); return result; } 

विधि कॉल

 const int count = 5; ConsoleExt.WriteLine("SumFromOneToCountAsyncIEnumerable started!"); var scs = await SumFromOneToCountTaskIEnumerable(count); ConsoleExt.WriteLine("SumFromOneToCountAsyncIEnumerable done!"); foreach (var sc in scs) { //   ,  .     . ConsoleExt.WriteLine($"AsyncIEnumerable Result: {sc}"); } ConsoleExt.WriteLine("################################################"); ConsoleExt.WriteLine(Environment.NewLine); 

निष्कर्ष:

जैसा कि आप उदाहरण से देख सकते हैं, सब कुछ एसिंक्रोनस मोड में गणना की जाती है, लेकिन समस्या अभी भी बनी हुई है। परिणाम (सभी परिणाम एक संग्रह में एकत्र किए जाते हैं) एकल ब्लॉक के रूप में लौटाए जाते हैं। और यह वह नहीं है जो हमें चाहिए। यदि आपको याद है, तो हमारा लक्ष्य विलंब की संभावना के साथ अतुल्यकालिक गणना मोड को संयोजित करना था।

ऐसा करने के लिए, आपको बाहरी पुस्तकालय का उपयोग करने की आवश्यकता है, उदाहरण के लिए, Ix (Rx का हिस्सा), या अतुल्यकालिक धागे, C # में प्रस्तुत किया गया है।

आइए अपने कोड पर वापस जाएं। अतुल्यकालिक व्यवहार प्रदर्शित करने के लिए, मैंने एक बाहरी पुस्तकालय का उपयोग किया।

 static async Task ConsumeAsyncSumSeqeunc(IAsyncEnumerable<int> sequence) { ConsoleExt.WriteLineAsync("ConsumeAsyncSumSeqeunc Called"); await sequence.ForEachAsync(value => { ConsoleExt.WriteLineAsync($"Consuming the value: {value}"); //    Task.Delay(TimeSpan.FromSeconds(1)).Wait(); }); } static IEnumerable<int> ProduceAsyncSumSeqeunc(int count) { ConsoleExt.WriteLineAsync("ProduceAsyncSumSeqeunc Called"); var sum = 0; for (var i = 0; i <= count; i++) { sum = sum + i; //    Task.Delay(TimeSpan.FromSeconds(0,5)).Wait(); yield return sum; } } 

विधि कॉल

 const int count = 5; ConsoleExt.WriteLine("Starting Async Streams Demo!"); //   .       . IAsyncEnumerable<int> pullBasedAsyncSequence = ProduceAsyncSumSeqeunc(count).ToAsyncEnumerable(); ConsoleExt.WriteLineAsync("X#X#X#X#X#X#X#X#X#X# Doing some other work X#X#X#X#X#X#X#X#X#X#"); //    ;      . var consumingTask = Task.Run(() => ConsumeAsyncSumSeqeunc(pullBasedAsyncSequence)); //   . ,    . consumingTask.Wait(); ConsoleExt.WriteLineAsync("Async Streams Demo Done!"); 

निष्कर्ष:

अंत में, हम वांछित व्यवहार देखते हैं। आप अतुल्यकालिक मोड में एक एन्यूमरेशन लूप चला सकते हैं।
स्रोत कोड यहां देखें

उदाहरण के रूप में क्लाइंट-सर्वर आर्किटेक्चर का उपयोग करके अतुल्यकालिक डेटा खींचना

आइए इस अवधारणा को अधिक यथार्थवादी उदाहरण के साथ देखें। इस फीचर के सभी लाभ क्लाइंट-सर्वर आर्किटेक्चर के संदर्भ में सबसे अच्छे रूप में देखे जाते हैं।

क्लाइंट-सर्वर आर्किटेक्चर के मामले में सिंक्रोनस कॉल

सर्वर को एक अनुरोध भेजते समय, ग्राहक को प्रतीक्षा करने के लिए मजबूर किया जाता है (यानी, यह अवरुद्ध है) जब तक कोई प्रतिक्रिया नहीं आती है, जैसा कि अंजीर में दिखाया गया है। -3।

अंजीर। -3- सिंक्रोनस डेटा पुलिंग, जिसके दौरान क्लाइंट अनुरोध प्रक्रिया पूरी होने तक प्रतीक्षा करता है

अतुल्यकालिक डेटा पुलिंग

इस मामले में, ग्राहक डेटा का अनुरोध करता है और अन्य कार्यों के लिए आगे बढ़ता है। डेटा प्राप्त होने के बाद, क्लाइंट काम करना जारी रखेगा।

अंजीर। -4- अतुल्यकालिक डेटा पुलिंग जिसके दौरान ग्राहक अन्य कार्यों को कर सकता है जबकि डेटा का अनुरोध किया जा रहा है

डेटा को अतुल्यकालिक रूप से खींचना

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

अंजीर। -5- एक अतुल्यकालिक अनुक्रम (अतुल्यकालिक धाराओं) के रूप में डेटा खींचना। ग्राहक अवरुद्ध नहीं है।

अतुल्यकालिक धागे

IEnumerable<T> और IEnumerator<T> दो नए IAsyncEnumerable<T> और IAsyncEnumerator<T> इंटरफेस हैं, जिन्हें नीचे दर्शाया गया है:

 public interface IAsyncEnumerable<out T> { IAsyncEnumerator<T> GetAsyncEnumerator(); } public interface IAsyncEnumerator<out T> : IAsyncDisposable { Task<bool> MoveNextAsync(); T Current { get; } } //      public interface IAsyncDisposable { Task DiskposeAsync(); } 

InfoQ में, जोनाथन एलन को यह विषय सही लगा। यहां मैं विवरण में नहीं जाऊंगा, इसलिए मैं उनके लेख को पढ़ने की सलाह देता हूं।

फोकस Task<bool> MoveNextAsync() बदल जाता है (बूल से Task<bool> परिवर्तित Task<bool> , bool IEnumerator.MoveNext() )। उसके लिए धन्यवाद, सभी गणना, साथ ही साथ उनकी पुनरावृत्ति, अतुल्यकालिक रूप से होगी। उपभोक्ता अगले मूल्य को कब तय करता है। हालांकि यह एक अतुल्यकालिक मॉडल है, फिर भी यह डेटा पुलिंग का उपयोग करता है। संसाधनों की अतुल्यकालिक सफाई के लिए, आप IAsyncDisposable इंटरफ़ेस का उपयोग कर सकते हैं। अतुल्यकालिक धागे के बारे में अधिक जानकारी यहां पाई जा सकती है ।

वाक्य-विन्यास

अंतिम सिंटैक्स को निम्नलिखित की तरह दिखना चाहिए:

 foreach await (var dataChunk in asyncStreams) { //        yield    . } 

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

पुन: डिज़ाइन किया गया Microsoft उदाहरण

मैंने Microsoft के डेमो कोड को फिर से लिखा है। इसे पूरी तरह से मेरे GitHub रिपॉजिटरी से डाउनलोड किया जा सकता है ।

उदाहरण स्मृति में एक बड़ी धारा (20,000 बाइट्स की एक सरणी) बनाने और एसिंक्रोनस मोड से क्रमिक रूप से इसे निकालने वाले तत्वों पर आधारित है। प्रत्येक पुनरावृत्ति के दौरान, सरणी से 8 KB खींचा जाता है।

चरण (1) में, एक बड़ा डेटा ऐरे बनाया जाता है, जो डमी मूल्यों से भरा होता है। फिर, चरण (2) के दौरान, चेकसम नामक एक चर को परिभाषित किया जाता है। चेकसम वाले इस चर का उद्देश्य गणना के योग की शुद्धता को सत्यापित करना है। एक सरणी और एक चेकसम को स्मृति में बनाया जाता है और चरण (3) में तत्वों के अनुक्रम के रूप में वापस किया जाता है।

चरण (4) में AsEnumarble एक्सटेंशन AsEnumarble (एक अधिक उपयुक्त नाम AsAsyncEnumarble) को लागू करना शामिल है, जो 8 KB (बफ़रसाइज़ = 8000 एलिमेंट्स (6)) की एक अतुल्यकालिक धारा का अनुकरण करने में मदद करता है

यह आमतौर पर IAsyncEnumerable से वारिस करने के लिए आवश्यक नहीं है, लेकिन ऊपर दिखाए गए उदाहरण में, यह ऑपरेशन डेमो कोड को सरल बनाने के लिए किया जाता है, जैसा कि चरण (5) में दिखाया गया है।

चरण (7) में foreach कीवर्ड का उपयोग शामिल है, जो मेमोरी में एक एसिंक्रोनस स्ट्रीम से 8 KB डेटा को निकालता है। खींचने की प्रक्रिया क्रमिक रूप से होती है: जब उपभोक्ता (कोड का हिस्सा होता है) डेटा का अगला टुकड़ा प्राप्त करने के लिए तैयार होता है, तो वह उन्हें प्रदाता (मेमोरी में स्ट्रीम में निहित सरणी) से खींचता है। अंत में, जब चक्र पूरा हो जाता है, तो प्रोग्राम चेकसम के लिए 'c' के मान की जांच करेगा और यदि वे मेल खाते हैं, तो यह कदम (8) के अनुसार संदेश "चेकसम मैच" दिखाएगा।

Microsoft डेमो आउटपुट विंडो:

निष्कर्ष

हमने एसिंक्रोनस थ्रेड्स को देखा, जो एसिंक्रोनस रूप से डेटा खींचने और कोड लिखने के लिए महान हैं जो एसिंक्रोनस मोड में कई मान उत्पन्न करता है।
इस मॉडल का उपयोग करके, आप अगले डेटा तत्व को अनुक्रम में क्वेरी कर सकते हैं और प्रतिक्रिया प्राप्त कर सकते हैं। यह IObservable<T> डेटा पुश मॉडल से भिन्न होता है, जिसके उपयोग से उपभोक्ता की स्थिति की परवाह किए बिना मान उत्पन्न होते हैं। अतुल्यकालिक धाराएं आपको उपभोक्ता द्वारा नियंत्रित अतुल्यकालिक डेटा स्रोतों का पूरी तरह से प्रतिनिधित्व करने की अनुमति देती हैं, जब वह स्वयं डेटा के अगले टुकड़े को स्वीकार करने की इच्छा निर्धारित करता है। उदाहरणों में वेब एप्लिकेशन का उपयोग करना या डेटाबेस में रिकॉर्ड पढ़ना शामिल है।

मैंने दिखाया कि कैसे एसिंक्रोनस मोड में एक एन्यूमरेशन बनाया जाता है और एसिंक्रोनस अनुक्रम के साथ बाहरी लाइब्रेरी का उपयोग करके इसका उपयोग किया जाता है। मैंने यह भी दिखाया कि इंटरनेट से सामग्री डाउनलोड करते समय यह सुविधा क्या लाभ प्रदान करती है। अंत में, हमने एसिंक्रोनस थ्रेड्स के लिए नए सिंटैक्स को देखा, साथ ही साथ Microsoft बिल्ड डेमो कोड ( 7–9 मई, 2018 // सिएटल, WA ) पर आधारित इसके उपयोग का एक पूरा उदाहरण भी देखा ।