"हो सकता है कि मैं async के माध्यम से मोनाड / C # में इंतजार कर (कोई कार्य नहीं!)

सामान्यीकृत async रिटर्न प्रकार - यह एक नया C # 7 फीचर है जो न केवल टास्क को एक प्रकार के एस्किंस तरीकों के रूप में उपयोग करने की अनुमति देता है, बल्कि अन्य प्रकार (कक्षाएं या संरचनाएं) भी हैं जो कुछ विशिष्ट आवश्यकताओं को पूरा करती हैं।

इसी समय, एसिंक्स / वेट कुछ संदर्भ के अंदर "निरंतरता" कार्यों के एक सेट को कॉल करने का एक तरीका है जो एक अन्य डिजाइन पैटर्न का एक सार है - मोनाड । तो, क्या हम एक कोड लिखने के लिए async / वेट का उपयोग कर सकते हैं जो उसी तरह से व्यवहार करेगा जैसे कि हम साधुओं का उपयोग करते हैं? यह पता चला है कि - हाँ (कुछ आरक्षणों के साथ)। उदाहरण के लिए, नीचे दिया गया कोड संकलित और काम कर रहा है:

async Task Main() { foreach (var s in new[] { "1,2", "3,7,1", null, "1" }) { var res = await Sum(s).GetMaybeResult(); Console.WriteLine(res.IsNothing ? "Nothing" : res.GetValue().ToString()); } // 3, 11, Nothing, Nothing } async Maybe<int> Sum(string input) { var args = await Split(input);//No result checking var result = 0; foreach (var arg in args) result += await Parse(arg);//No result checking return result; } Maybe<string[]> Split(string str) { var parts = str?.Split(',').Where(s=>!string.IsNullOrWhiteSpace(s)).ToArray(); return parts == null || parts.Length < 2 ? Maybe<string[]>.Nothing() : parts; } Maybe<int> Parse(string str) => int.TryParse(str, out var result) ? result : Maybe<int>.Nothing(); 

इसके अलावा, मैं समझाऊंगा कि कोड कैसे काम करता है ...

सामान्यकृत async रिटर्न प्रकार

सबसे पहले आइए जानें कि हमारे अपने प्रकार (जैसे MyAwaitable <T> ) का उपयोग करने के लिए क्या आवश्यक है, जिसके परिणामस्वरूप कुछ विशेष प्रकार के फ़ंक्शन होते हैं। दस्तावेज़ीकरण कहता है कि इस प्रकार का होना आवश्यक है:

1. GetAwaiter () विधि जो एक प्रकार की एक वस्तु लौटाती है जो INotifyCompletion इंटरफ़ेस को लागू करती है और जिसके पास IsCompleted property और T GetResult () मेथड है;

   
   

2. [AsyncMethodBuilder (प्रकार)] विशेषता जो "विधि निर्माता" वर्ग ( या संरचना ) को इंगित करता है जैसे MyAwaitableTaskMethodBuilder <T> निम्नलिखित विधियों के साथ:

   
   
   • स्थिर बनाएँ ()
   • प्रारंभ (राज्यमंच)
   • SetResult (परिणाम)
   • SetException (अपवाद)
   • SetStateMachine (StateMachine)
   • प्रतीक्षारत (प्रतीक्षारत, राज्यमंच)
   • AwaitUnsafeOnCompleted (प्रतीक्षाकर्ता, राज्यमशीन)
   • कार्य
   
   

 [AsyncMethodBuilder(typeof(MyAwaitableTaskMethodBuilder<>))] public class MyAwaitable<T> : INotifyCompletion { private Action _continuation; public MyAwaitable() { } public MyAwaitable(T value) { this.Value = value; this.IsCompleted = true; } public MyAwaitable<T> GetAwaiter() => this; public bool IsCompleted { get; private set; } public T Value { get; private set; } public Exception Exception { get; private set; } public T GetResult() { if (!this.IsCompleted) throw new Exception("Not completed"); if (this.Exception != null) { ExceptionDispatchInfo.Throw(this.Exception); } return this.Value; } internal void SetResult(T value) { if (this.IsCompleted) throw new Exception("Already completed"); this.Value = value; this.IsCompleted = true; this._continuation?.Invoke(); } internal void SetException(Exception exception) { this.IsCompleted = true; this.Exception = exception; } void INotifyCompletion.OnCompleted(Action continuation) { this._continuation = continuation; if (this.IsCompleted) { continuation(); } } } public class MyAwaitableTaskMethodBuilder<T> { public MyAwaitableTaskMethodBuilder() => this.Task = new MyAwaitable<T>(); public static MyAwaitableTaskMethodBuilder<T> Create() => new MyAwaitableTaskMethodBuilder<T>(); public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine => stateMachine.MoveNext(); public void SetStateMachine(IAsyncStateMachine stateMachine) { } public void SetException(Exception exception) => this.Task.SetException(exception); public void SetResult(T result) => this.Task.SetResult(result); public void AwaitOnCompleted<TAwaiter, TStateMachine>( ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine => this.GenericAwaitOnCompleted(ref awaiter, ref stateMachine); public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>( ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine => this.GenericAwaitOnCompleted(ref awaiter, ref stateMachine); public void GenericAwaitOnCompleted<TAwaiter, TStateMachine>( ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine => awaiter.OnCompleted(stateMachine.MoveNext); public MyAwaitable<T> Task { get; } } 

अब हम MyAwaitable को async विधियों के परिणामस्वरूप उपयोग कर सकते हैं:

 private async MyAwaitable<int> MyAwaitableMethod() { int result = 0; int arg1 = await this.GetMyAwaitable(1); result += arg1; int arg2 = await this.GetMyAwaitable(2); result += arg2; int arg3 = await this.GetMyAwaitable(3); result += arg3; return result; } private async MyAwaitable<int> GetMyAwaitable(int arg) { await Task.Delay(1);//Simulate asynchronous execution return await new MyAwaitable<int>(arg); } 

कोड अपेक्षित रूप से काम करता है लेकिन MyAwaitable को आवश्यकताओं के एक उद्देश्य को समझने के लिए आइए एक नज़र डालते हैं कि C # प्रीप्रोसेसर MyAwaitableMethod के साथ क्या करता है। यदि आप कुछ डी-संकलन उपयोग (जैसे डॉटपेक) चलाते हैं, तो आप देखेंगे कि मूल विधि निम्नानुसार बदल दी गई थी:

 private MyAwaitable<int> MyAwaitableMethod() { var stateMachine = new MyAwaitableMethodStateMachine(); stateMachine.Owner = this; stateMachine.Builder = MyAwaitableTaskMethodBuilder<int>.Create(); stateMachine.State = 0; stateMachine.Builder.Start(ref stateMachine); return stateMachine.Builder.Task; } 

 sealed class MyAwaitableMethodStateMachine : IAsyncStateMachine { public int State; public MyAwaitableTaskMethodBuilder<int> Builder; public BuilderDemo Owner; private int _result; private int _arg1; private int _arg2; private int _arg3; private MyAwaitableAwaiter<int> _awaiter1; private MyAwaitableAwaiter<int> _awaiter2; private MyAwaitableAwaiter<int> _awaiter3; private void SetAwaitCompletion(INotifyCompletion awaiter) { var stateMachine = this; this.Builder.AwaitOnCompleted(ref awaiter, ref stateMachine); } void IAsyncStateMachine.MoveNext() { int finalResult; try { label_begin: switch (this.State) { case 0: this._result = 0; this._awaiter1 = this.Owner.GetMyAwaitable(1).GetAwaiter(); this.State = 1; if (!this._awaiter1.IsCompleted) { this.SetAwaitCompletion(this._awaiter1); return; } goto label_begin; case 1:// awaiter1 should be completed this._arg1 = this._awaiter1.GetResult(); this._result += this._arg1; this.State = 2; this._awaiter2 = this.Owner.GetMyAwaitable(2).GetAwaiter(); if (!this._awaiter2.IsCompleted) { this.SetAwaitCompletion(this._awaiter2); return; } goto label_begin; case 2:// awaiter2 should be completed this._arg2 = this._awaiter2.GetResult(); this._result += this._arg2; this.State = 3; this._awaiter3 = this.Owner.GetMyAwaitable(3).GetAwaiter(); if (!this._awaiter3.IsCompleted) { this.SetAwaitCompletion(this._awaiter3); return; } goto label_begin; case 3:// awaiter3 should be completed this._arg3 = this._awaiter3.GetResult(); this._result += this._arg3; finalResult = this._result; break; default: throw new Exception(); } } catch (Exception ex) { this.State = -1; this.Builder.SetException(ex); return; } this.State = -1; this.Builder.SetResult(finalResult); } } 

उत्पन्न कोड की समीक्षा करते हुए हम देख सकते हैं कि "मेथड बिल्डर" की निम्नलिखित जिम्मेदारियाँ हैं:

1. एक बच्चे के अतुल्यकालिक ऑपरेशन किया जाता है जब राज्य मशीन MoveNext () विधि कॉल शेड्यूलिंग (सबसे सरल परिदृश्य में हम सिर्फ MoveNext () OnCompleted ( async ऑपरेशन वेटर के) में पास करते हैं।
2. एक अतुल्यकालिक ऑपरेशन संदर्भ वस्तु का निर्माण ( public MyAwaitable<T> Task { get; } )
3. उत्पन्न राज्य मशीनों के अंतिम राज्यों पर प्रतिक्रिया: SetResult या SetException ।

दूसरे शब्दों में, "विधि बिल्डरों" के साथ हम इस पर नियंत्रण पा सकते हैं कि कैसे अतुल्यकालिक तरीकों को निष्पादित किया जाता है और यह एक ऐसी सुविधा की तरह दिखता है जो हमें अपने लक्ष्य को प्राप्त करने में मदद करेगा - शायद मोनड व्यवहार का कार्यान्वयन। लेकिन उस सन्यासी के बारे में क्या अच्छा है? खैर ... आप इंटरनेट में उस सन्यासी के बारे में बहुत सारे लेख पा सकते हैं, इसलिए यहां मैं सिर्फ मूल बातें बताऊंगा।

शायद मोनद

संक्षेप में, शायद मोनड एक डिज़ाइन पैटर्न है जो फ़ंक्शन कॉल श्रृंखला में रुकावट की अनुमति देता है यदि श्रृंखला से कुछ फ़ंक्शन एक मूल्यवान परिणाम (जैसे पार्सिंग त्रुटि) उत्पन्न नहीं कर सकता है।

ऐतिहासिक रूप से, अनिवार्य प्रोग्रामिंग भाषाएं दो तरीकों से समस्या का समाधान कर रही हैं:

1. सशर्त तर्क की बहुत
2. अपवाद

दोनों तरीकों से स्पष्ट नुकसान हैं, इसलिए एक तीसरे तरीके का आविष्कार किया गया था:

1. एक प्रकार बनाएं जो 2 राज्यों में हो सकता है: "कुछ मूल्य" और "कुछ नहीं" - चलो इसे "शायद" कहते हैं
2. एक फ़ंक्शन बनाएं (इसे "SelectMany" कहते हैं) जो 2 तर्क देता है:
   2.1। "शायद" प्रकार की एक वस्तु
   2.2। कॉल सेट से एक अगला फ़ंक्शन - फ़ंक्शन को "शायद" का एक ऑब्जेक्ट भी वापस करना चाहिए, जिसमें एक परिणाम या "कुछ भी नहीं" होगा यदि इसका परिणाम मूल्यांकन नहीं किया जा सकता है (उदाहरण के लिए फ़ंक्शन पैरामीटर सही प्रारूप में नहीं हैं)
3. "SelectMany" फ़ंक्शन जाँचता है कि "शायद" का कुछ मूल्य है और फिर अगले फ़ंक्शन को एक तर्क के रूप में मान ("शायद" से निकाला गया) का उपयोग करके कॉल करता है और फिर अपना परिणाम देता है, अन्यथा यह "कुछ भी नहीं" स्थिति में "शायद" वस्तु देता है ।

C # में इसे इस तरह लागू किया जा सकता है:

 public struct Maybe<T> { public static implicit operator Maybe<T>(T value) => Value(value); public static Maybe<T> Value(T value) => new Maybe<T>(false, value); public static readonly Maybe<T> Nothing = new Maybe<T>(true, default); private Maybe(bool isNothing, T value) { this.IsNothing = isNothing; this._value = value; } public readonly bool IsNothing; private readonly T _value; public T GetValue() => this.IsNothing ? throw new Exception("Nothing") : this._value; } public static class MaybeExtensions { public static Maybe<TRes> SelectMany<TIn, TRes>( this Maybe<TIn> source, Func<TIn, Maybe<TRes>> func) => source.IsNothing ? Maybe<TRes>.Nothing : func(source.GetValue()); } 

और उपयोग:

 static void Main() { for (int i = 0; i < 10; i++) { var res = Function1(i).SelectMany(Function2).SelectMany(Function3); Console.WriteLine(res.IsNothing ? "Nothing" : res.GetValue().ToString()); } Maybe<int> Function1(int acc) => acc < 10 ? acc + 1 : Maybe<int>.Nothing; Maybe<int> Function2(int acc) => acc < 10 ? acc + 2 : Maybe<int>.Nothing; Maybe<int> Function3(int acc) => acc < 10 ? acc + 3 : Maybe<int>.Nothing; } 

 var res = Function1(i) .SelectMany(x2 => Function2(x2).SelectMany(x3 => Function3(x3.SelectMany<int, int>(x4 => x2 + x3 + x4))); 

 var res = from x2 in Function1(i) from x3 in Function2(x2) from x4 in Function3(x3) select x2 + x3 + x4; 

 public static Maybe<TJ> SelectMany<TIn, TRes, TJ>( this Maybe<TIn> source, Func<TIn, Maybe<TRes>> func, Func<TIn, TRes, TJ> joinFunc) { if (source.IsNothing) return Maybe<TJ>.Nothing; var res = func(source.GetValue()); return res.IsNothing ? Maybe<TJ>.Nothing : joinFunc(source.GetValue(), res.GetValue()); } 

 static void Main() { foreach (var s in new[] {"1,2", "3,7,1", null, "1"}) { var res = Sum(s); Console.WriteLine(res.IsNothing ? "Nothing" : res.GetValue().ToString()); } Console.ReadKey(); } static Maybe<int> Sum(string input) => Split(input).SelectMany(items => Acc(0, 0, items)); //Recursion is used to process a list of "Maybes" static Maybe<int> Acc(int res, int index, IReadOnlyList<string> array) => index < array.Count ? Add(res, array[index]) .SelectMany(newRes => Acc(newRes, index + 1, array)) : res; static Maybe<int> Add(int acc, string nextStr) => Parse(nextStr).SelectMany<int, int>(nextNum => acc + nextNum); static Maybe<string[]> Split(string str) { var parts = str?.Split(',') .Where(s => !string.IsNullOrWhiteSpace(s)).ToArray(); return parts == null || parts.Length < 2 ? Maybe<string[]>.Nothing : parts; } static Maybe<int> Parse(string value) => int.TryParse(value, out var result) ? result : Maybe<int>.Nothing; 

Async हो सकता है

शायद मोनड का सार एक फ़ंक्शन कॉल श्रृंखला को नियंत्रित करना है, लेकिन यह ठीक है कि "async / प्रतीक्षा" करता है। तो चलो उन्हें एक साथ संयोजित करने का प्रयास करें। पहले, हमें अतुल्यकालिक कार्यों के साथ संगत प्रकार बनाने की आवश्यकता है और हम पहले से ही जानते हैं कि यह कैसे करना है:

 [AsyncMethodBuilder(typeof(MaybeTaskMethodBuilder<>))] public class Maybe<T> : INotifyCompletion { ... public Maybe<T> GetAwaiter() => this; public bool IsCompleted { get; private set; } public void OnCompleted(Action continuation){...} public T GetResult() =>... } 

अब आइए एक नज़र डालते हैं कि "शास्त्रीय हो सकता है" को किसी भी समानता को खोजने में सक्षम होने के लिए एक राज्य मशीन के रूप में कैसे लिखा जा सकता है:

 static void Main() { for (int i = 0; i < 10; i++) { var stateMachine = new StateMachine(); stateMachine.state = 0; stateMachine.i = i; stateMachine.MoveNext(); var res = stateMachine.Result; Console.WriteLine(res.IsNothing ? "Nothing" : res.GetValue().ToString()); } Console.ReadKey(); } class StateMachine { public int state = 0; public int i; public Maybe<int> Result; private Maybe<int> _f1; private Maybe<int> _f2; private Maybe<int> _f3; public void MoveNext() { label_begin: switch (this.state) { case 0: this._f1 = Function1(this.i); this.state = Match ? -1 : 1; goto label_begin; case 1: this._f2 = Function2(this._f1.GetValue()); this.state = this._f2.IsNothing ? -1 : 2; goto label_begin; case 2: this._f3 = Function3(this._f2.GetValue()); this.state = this._f3.IsNothing ? -1 : 3; goto label_begin; case 3: this.Result = this._f3.GetValue(); break; case -1: this.Result = Maybe<int>.Nothing; break; } } } 

यदि हम इस राज्य मशीन को C # प्रीप्रोसेसर एक (ऊपर देखें - 'MyAwaitableMethodStateMachine' द्वारा जनरेट करते हैं) के साथ मेल खाते हैं, तो हम देख सकते हैं कि शायद राज्य की जाँच अंदर लागू की जा सकती है:

 this.Builder.AwaitOnCompleted(ref awaiter, ref stateMachine); 

जहाँ ref awaiter शायद एक प्रकार की वस्तु है। यहां एकमात्र समस्या यह है कि हम मशीन को "अंतिम" (-1) स्थिति में सेट नहीं कर सकते हैं। इसका मतलब यह है कि हम निष्पादन प्रवाह को नियंत्रित नहीं कर सकते हैं? दरअसल, ऐसा नहीं है। बात यह है कि प्रत्येक अतुल्यकालिक कार्रवाई के लिए C # कॉलबैक एक्शन गर्त सेट करता है INotifyCompletion इंटरफ़ेस, इसलिए यदि हम एक निष्पादन प्रवाह को तोड़ना चाहते हैं तो हम कॉलबैक एक्शन को एक मामले में कॉल कर सकते हैं जब हम प्रवाह को जारी नहीं रख सकते।
यहां एक और चुनौती यह है कि उत्पन्न राज्य मशीन एक वर्तमान प्रवाह के रूप में एक अगली कार्रवाई (एक निरंतरता कॉलबैक के रूप में) गुजरती है, लेकिन हमें प्रारंभिक प्रवाह के निरंतरता कॉलबैक की आवश्यकता होती है जो कि एस्किंस संचालन के बाकी हिस्सों को दरकिनार करने की अनुमति देगा:

इसलिए, हमें किसी तरह से अपने पूर्वजों के साथ एक बच्चे को एस्कॉन कार्रवाई करने की आवश्यकता है। हम अपने "मेथड बिल्डर" का उपयोग कर सकते हैं, जिसमें एक वर्तमान async ऑपरेशन का लिंक है - कार्य । सभी चाइल्ड async ऑपरेशंस के लिंक AwaitOnCompleted(ref awaiter रूप में AwaitOnCompleted(ref awaiter में पास किए जाएंगे , इसलिए हमें बस यह जांचने की ज़रूरत है कि क्या पैरामीटर शायद एक उदाहरण है और यदि यह वर्तमान सेट है तो शायद बच्चे के लिए माता-पिता के रूप में।

 [AsyncMethodBuilder(typeof(MaybeTaskMethodBuilder<>))] public class Maybe<T> : IMaybe, INotifyCompletion { private IMaybe _parent; void IMaybe.SetParent(IMaybe parent) => this._parent = parent; ... } public class MaybeTaskMethodBuilder<T> { ... private void GenericAwaitOnCompleted<TAwaiter, TStateMachine>( ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { if (awaiter is IMaybe maybe) { maybe.SetParent(this.Task); } awaiter.OnCompleted(stateMachine.MoveNext); } ... } 

अब सभी हो सकता है कि वस्तुओं को एक पेड़ में जोड़ा जा सके और, परिणामस्वरूप, हम किसी भी वंशज नोड से रूट की निरंतरता ( एक्जिट विधि) तक पहुंच पाएंगे:

 [AsyncMethodBuilder(typeof(MaybeTaskMethodBuilder<>))] public class Maybe<T> : IMaybe, INotifyCompletion { private Action _continuation; private IMaybe _parent; ... public void OnCompleted(Action continuation) { ... this._continuation = continuation; ... } ... void IMaybe.Exit() { this.IsCompleted = true; if (this._parent != null) { this._parent.Exit(); } else { this._continuation(); } } ... } 

उस निकास विधि को तब बुलाया जाना चाहिए जब (पेड़ पर आगे बढ़ने के दौरान) हमें कुछ भी नहीं राज्य में पहले से ही हल की गई वस्तु मिल जाए। इस तरह की वस्तुओं को इस तरह से एक विधि द्वारा वापस किया जा सकता है:

 Maybe<int> Parse(string str) => int.TryParse(str, out var result) ? result : Maybe<int>.Nothing(); 

सुलझी हुई अवस्था को संचित करने के लिए, शायद एक अलग संरचना प्रस्तुत करें:

 public struct MaybeResult { ... private readonly T _value; public readonly bool IsNothing; public T GetValue() => this.IsNothing ? throw new Exception("Nothing") : this._value; } [AsyncMethodBuilder(typeof(MaybeTaskMethodBuilder<>))] public class Maybe<T> : IMaybe, INotifyCompletion { private MaybeResult? _result; ... internal Maybe() { }//Used in async method private Maybe(MaybeResult result) => this._result = result;// "Resolved" instance ... } 

जब कोई एस्किंट स्टेट मशीन कॉल करती है (मेथड बिल्डर के माध्यम से) तो ऑन-लाईक विधि पहले से ही हल हो सकती है शायद उदाहरण और यह कुछ भी नहीं है राज्य में हम एक संपूर्ण प्रवाह को तोड़ने में सक्षम होंगे:

 public void OnCompleted(Action continuation) { this._continuation = continuation; if(this._result.HasValue) { this.NotifyResult(this._result.Value.IsNothing); } } internal void SetResult(T result) //Is called by a "method builder" when an async method is completed { this._result = MaybeResult.Value(result); this.IsCompleted = true; this.NotifyResult(this._result.Value.IsNothing); } private void NotifyResult(bool isNothing) { this.IsCompleted = true; if (isNothing) { this._parent.Exit();//Braking an entire flow } else { this._continuation?.Invoke(); } } 

अब केवल एक चीज बची हुई है - एक async का परिणाम कैसे प्राप्त करें शायद इसके दायरे से बाहर (कोई async विधि जिसका वापसी प्रकार शायद नहीं है)। यदि आप शायद एक उदाहरण के साथ प्रतीक्षा करने वाले कीवर्ड का उपयोग करने का प्रयास करते हैं तो इस कोड के कारण एक अपवाद फेंक दिया जाएगा:

 [AsyncMethodBuilder(typeof(MaybeTaskMethodBuilder<>))] public class Maybe<T> : IMaybe, INotifyCompletion { private MaybeResult? _result; public T GetResult() => this._result.Value.GetValue(); } ... public struct MaybeResult { ... public T GetValue() => this.IsNothing ? throw new Exception("Nothing") : this._value; } 

इस समस्या को हल करने के लिए हम बस एक नया एवाटर जोड़ सकते हैं, जो कि पूरी तरह से हो सकता है। मूल संरचना और हम इस पर एक कोड लिखने में सक्षम होंगे:

 var res = await GetResult().GetMaybeResult(); if(res.IsNothing){ ... } else{ res.GetValue(); ... }; 

अभी के लिए बस इतना ही। कोड के नमूनों में मैं केवल सबसे महत्वपूर्ण भागों पर ध्यान केंद्रित करने के लिए कुछ विवरणों को छोड़ देता हूं। आप जीथब पर एक पूर्ण संस्करण पा सकते हैं।

हालाँकि , मैं इस संस्करण को किसी भी उत्पादन कोड में उपयोग करने की सिफारिश नहीं करूंगा क्योंकि इसमें एक महत्वपूर्ण मुद्दा है - जब हम रूट के एक निरंतरता को कॉल करके एक निष्पादन प्रवाह को तोड़ देंगे तो शायद हम सबको बायपास कर देंगे! सभी अंत में ब्लॉक सहित (यह सवाल का एक उत्तर है " आखिरकार ब्लॉक हमेशा कहा जाता है?"), इसलिए सभी ऑपरेटरों का उपयोग उम्मीद के मुताबिक काम नहीं करेगा और इससे संसाधन लीक हो सकता है। समस्या को हल किया जा सकता है यदि प्रारंभिक निरंतरता कॉलबैक को कॉल करने के बजाय हम एक विशेष अपवाद को फेंक देंगे जिसे आंतरिक रूप से नियंत्रित किया जाएगा ( यहां आप संस्करण पा सकते हैं ), लेकिन इस समाधान में स्पष्ट रूप से प्रदर्शन नकलें हैं (जो कुछ परिदृश्यों में स्वीकार्य हो सकती हैं)। C # संकलक के वर्तमान संस्करण के साथ मुझे कोई अन्य समाधान नहीं दिखता है लेकिन भविष्य में इसे बदला जा सकता है।

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