🥪 🍆 🤞🏽 C # में सामान्य लिस्प स्थिति प्रणाली को लागू करना 🌄 👩🏻‍🤝‍👨🏿 ▶️

कॉमन लिस्प की सबसे उल्लेखनीय और आकर्षक विशेषताओं में से एक, निश्चित रूप से, इसका अपवाद हैंडलिंग सिस्टम है।

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

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

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

कई अन्य प्रोग्रामिंग भाषाओं में समान तंत्र की अनुपस्थिति के बावजूद (यदि सभी नहीं), तो यह उनमें से अधिकांश पर कम या ज्यादा संत रूप में कार्यान्वयन के लिए उधार देता है। इस अनुच्छेद में, मैं सी # में कार्यान्वयन का वर्णन करूंगा, जिस तरह से, "अपवादों" के लिए इस दृष्टिकोण की बहुत अवधारणा का विस्तार से विश्लेषण कर रहा हूं।

प्रोग्रामिंग भाषा से CLCS को पूरी तरह से लागू करने के लिए, या इसके रनटाइम से भी, निम्नलिखित कुछ चीजों की आवश्यकता होती है:

सख्त स्टैक मॉडल। यहाँ, मेरा मतलब है भाषा में पूर्ण "निरंतरता" की कमी। यह बिंदु सशर्त है, लेकिन चूँकि निरंतरता, संगणना के प्रवाह नियंत्रण तंत्र में भारी फ़िज़नेस का परिचय देती है, और वे पर्याप्त सटीकता के साथ यह निर्धारित करने की अनुमति नहीं देते हैं कि मूल प्राइमेटिक्स जिनसे सीएलसीएस को निरस्त किया गया है, उनकी उपस्थिति अत्यंत अवांछनीय है।
उच्च-क्रम फ़ंक्शन, अनाम फ़ंक्शन और क्लोज़र। बेशक, यदि आप कोशिश करते हैं, तो आप वस्तुओं और कक्षाओं के माध्यम से सब कुछ लागू कर सकते हैं, लेकिन इस मामले में, मेरी राय में, इन सभी का उपयोग करना, बहुत असुविधाजनक होगा।
गतिशील वातावरण और, विशेष रूप से, गतिशील चर। गतिशील वातावरण और चर के बारे में, मैंने अपने लेख में आधुनिक लिस्प के शब्दार्थ के बारे में अधिक या कम विवरण में लिखा है: love5an.livejournal.com/371169.html
एक प्रोग्रामिंग भाषा में एक समान अवधारणा की अनुपस्थिति में, हालांकि, निम्नलिखित दो बिंदुओं का उपयोग करके इसका अनुकरण किया जाता है:
कोशिश, पकड़, और बयान, या उनके समकक्ष फेंक देते हैं। ये ऑपरेटर किसी भी प्रोग्रामिंग भाषा में हैं जो अपवादों का समर्थन करते हैं।
UNWIND-PROTECT आदिम या उसके अनुरूप (कोशिश अंत में ब्लॉक, RAII, आदि)।

हम निम्नलिखित सीएल अपवाद प्रणाली आदिमता को C # में पोर्ट करेंगे:

हैंडलर-बाइंड - स्टेटमेंट बॉडी के निष्पादन समय के लिए एक अपवाद हैंडलर सेट करता है। अपवाद को पकड़ने पर, हैंडलर स्टैक को बढ़ावा देने का निर्णय ले सकता है, लेकिन ऐसा करने की आवश्यकता नहीं है।
हैंडलर-केस - ऑपरेटर बॉडी के निष्पादन समय के लिए एक अपवाद हैंडलर सेट करता है। जब एक अपवाद को पकड़ते हैं, तो स्टैक निराधार होता है और ऑपरेटर हैंडलर के शरीर में गणना किए गए मान को लौटाता है।
संकेत - एक उच्च हैंडलर के अपवाद को दर्शाता है, अगर कोई मौजूद है।
त्रुटि - एक अपस्ट्रीम हैंडलर के अपवाद को इंगित करता है, और इसके अभाव में, या अपवाद के साथ सामना करने के लिए सभी हैंडलर की विफलता के मामले में - सामान्य तरीके से अपवाद फेंकता है, अर्थात्। थ्रो ऑपरेटर के साथ (यह हमारे कार्यान्वयन में है। कॉमन लिस्प में, त्रुटि फ़ंक्शन डिबगर को कॉल करता है यदि कोई जुड़ा हुआ है, या, अन्यथा, गणना का एक अलग धागा या संपूर्ण लिस्प सिस्टम समाप्त करता है।)
रिस्टार्ट-बाइंड - एक "रिस्टार्ट" सेट करता है, जिससे स्टैक प्रमोशन मैकेनिज्म नहीं होता है। पुनरारंभ करना वर्तमान गतिशील वातावरण में एक फ़ंक्शन है (ऊपर लेख के लिए लिंक देखें) जो किसी अपवाद का जवाब दे सकता है। रेस्टार्ट्स को आमतौर पर कार्यक्रम के उन स्थानों पर रखा जाता है जहां आप किसी तरह हुई त्रुटि को ठीक कर सकते हैं। वे आमतौर पर अपवाद हैंडलर से शुरू किए जाते हैं (नीचे देखें)।
पुनः आरंभ-मामला - "पुनः आरंभ" सेट करता है, स्टैक के प्रचार के साथ समाप्त होता है।
पुनः आरंभ - नाम से "पुनः आरंभ" ढूँढता है।
आह्वान-पुनः आरंभ - नाम से "पुनः आरंभ" पाता है और इसे शुरू करता है।
कंप्यूट-रिस्टार्ट - वर्तमान डायनामिक वातावरण में स्थापित सभी "रिस्टार्ट" की सूची की गणना करता है।
खोलना-सुरक्षित करना - ऑपरेटर के शरीर के एक ब्लॉक को निष्पादित करता है, और फिर - भले ही निष्पादन सामान्य तरीके से पूरा हो, या स्टैक के जबरन प्रचार के बावजूद - यह सभी निर्दिष्ट "सुरक्षा" ब्लॉक (फ़ंक्शन) करता है।

आप अध्याय 19 में पीटर सिबेल की अद्भुत पुस्तक प्रैक्टिकल कॉमन लिस्प में अपवाद हैंडलिंग से संबंधित इन और अन्य प्राथमिकताओं के बारे में अधिक पढ़ सकते हैं:
lisper.ru/pcl/beyond-exception-handling-conditions-and-restarts

हमारे सभी कार्यान्वयन स्थिर वर्ग स्थितियों में निहित होंगे। आगे, मैं उनके तरीकों का वर्णन करूँगा।
लेकिन सबसे पहले, स्थिर चर के एक जोड़े का वर्णन किया जाना चाहिए।

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

static ConditionalWeakTable<Thread, Stack<Tuple<Type, HandlerBindCallback>>> _handlerStacks; static ConditionalWeakTable<Thread, Stack<Tuple<string, RestartBindCallback>>> _restartStacks; static Conditions() { _handlerStacks = new ConditionalWeakTable<Thread, Stack<Tuple<Type, HandlerBindCallback>>>(); _restartStacks = new ConditionalWeakTable<Thread, Stack<Tuple<string, RestartBindCallback>>>(); }

"थ्रेड -> स्टैक" डिक्शनरी के लिए, मैंने .NET 4.0 में जोड़े गए ConditionalWeakTable क्लास को चुना, लेकिन आप किसी अन्य समान डेटा संरचना का उपयोग कर सकते हैं। ConditionalWeakTable अच्छा है क्योंकि यह "कमजोर संकेत" (WeakPointer - इसलिए कक्षा के नाम में कमजोर है) कुंजी के साथ एक हैश-प्लेट है, और इसके अनुसार, इसका मतलब है कि जब कचरा कलेक्टर द्वारा थ्रेड ऑब्जेक्ट हटा दिया जाता है, तो हम लीक नहीं करेंगे स्मृति।

अपवाद हैंडलर और सिग्नलिंग

HandlerBind

 public static T HandlerBind<T>(Type exceptionType, HandlerBindCallback handler, HandlerBody<T> body) { if (null == exceptionType) throw new ArgumentNullException("exceptionType"); if (!exceptionType.IsSubclassOf(typeof(Exception))) throw new InvalidOperationException("exceptionType is not a subtype of System.Exception"); if (null == handler) throw new ArgumentNullException("handler"); if (null == body) throw new ArgumentNullException("body"); Thread currentThread = Thread.CurrentThread; var clusters = _handlerStacks.GetOrCreateValue(currentThread); clusters.Push(Tuple.Create(exceptionType, handler)); try { return body(); } finally { clusters.Pop(); } }

हैंडलरबाइंड विधि तीन मापदंडों को लेती है: हैंडलर के साथ जुड़े अपवाद का प्रकार (जैसा कि विधि के शरीर से देखा जा सकता है, यह अपवाद का एक उप-वर्ग होना चाहिए), एक कॉलबैक जो हैंडलर के कोड को परिभाषित करता है, और एक अन्य प्रतिनिधि जो कोड को परिभाषित करता है जिसे कथन के शरीर में निष्पादित किया जाता है।
प्रतिनिधि प्रकार हैंडलर और बॉडी हैं:

 public delegate void HandlerBindCallback(Exception exception); public delegate T HandlerBody<T>();

हैंडलर के पास तर्क के रूप में दिया गया अपवाद पैरामीटर अपवाद ऑब्जेक्ट ही है।

जैसा कि आप देख सकते हैं, हैंडलरबाइंड का कार्यान्वयन सरल है - हम वर्तमान थ्रेड से जुड़े हैंडलर्स के ढेर में एक नया जोड़ते हैं, उसके बाद हम ऑपरेटर बॉडी के कोड को निष्पादित करते हैं, और परिणामस्वरूप, आखिरकार बॉडी में हैंडलर को स्टैक से हटा देते हैं। इस प्रकार, अपवाद हैंडलर का स्टैक वर्तमान थ्रेड के निष्पादन स्टैक के साथ जुड़ा हुआ है, और जब प्रोग्राम निष्पादन थ्रेड इसी स्टैक फ़्रेम को छोड़ता है, तो प्रत्येक स्थापित हैंडलर अमान्य हो जाता है।

HandlerCase

 public static T HandlerCase<T>(Type exceptionType, HandlerCaseCallback<T> handler, HandlerBody<T> body) { if (null == exceptionType) throw new ArgumentNullException("exceptionType"); if (!exceptionType.IsSubclassOf(typeof(Exception))) throw new InvalidOperationException("exceptionType is not a subtype of System.Exception"); if (null == handler) throw new ArgumentNullException("handler"); if (null == body) throw new ArgumentNullException("body"); var unwindTag = new UnwindTag<T>(); HandlerBindCallback handlerCallback = (e) => { unwindTag.Value = handler(e); throw unwindTag; }; try { return HandlerBind(exceptionType, handlerCallback, body); } catch (UnwindTag<T> e) { if (e == unwindTag) { return e.Value; } else throw; } }

हैंडलरकैस को लागू करना थोड़ा अधिक जटिल है। हैंडलरबाइंड से अंतर, मुझे याद है, यह है कि यह ऑपरेटर उस बिंदु पर स्टैक को स्पिन करता है जिस पर हैंडलर स्थापित है। चूँकि स्पष्ट रूप से भागने की निरंतरता C # में निषिद्ध है (अर्थात मोटे तौर पर, हम गोटो नहीं बना सकते हैं या एक लैम्ब्डा से वापस लौटने पर स्टैक को एक बाहरी ब्लॉक में पारित कर दिया जाता है), हम स्टैक को कम करने के लिए नियमित प्रयास करते हैं, और प्रोसेसर ब्लॉक की पहचान करते हैं सहायक वर्ग UnwindTag की एक वस्तु

 class UnwindTag<T> : Exception { public T Value { get; set; } }

हैंडलरकैसलबैक हैंडलरबाइंडबैक से भिन्न होता है केवल उसी में यह मान देता है:

 public delegate T HandlerCaseCallback<T>(Exception exception);

संकेत

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

 public static void Signal<T>(T exception) where T : Exception { if (null == exception) throw new ArgumentNullException("exception"); Thread currentThread = Thread.CurrentThread; var clusters = _handlerStacks.GetOrCreateValue(currentThread); var i = clusters.GetEnumerator(); while (i.MoveNext()) { var type = i.Current.Item1; var handler = i.Current.Item2; if (type.IsInstanceOfType(exception)) { handler(exception); break; } } }

जाहिरा तौर पर - सब कुछ बहुत सरल है। अपवाद संचालकों के वर्तमान ढेर से, हम पहले वाले को अपवाद वर्ग के साथ काम कर सकते हैं, जिसका एक उदाहरण अपवाद पैरामीटर में हमारे पास पारित वस्तु है।

त्रुटि

 public static void Error<T>(T exception) where T : Exception { Signal(exception); throw exception; }

त्रुटि केवल सिग्नल से भिन्न होती है कि यह एक उपयुक्त हैंडलर की अनुपस्थिति में प्रोग्राम निष्पादन के सामान्य प्रवाह को बाधित करती है। अगर हम "फेंक अपवाद" के बजाय .NET के तहत आम लिस्प का पूर्ण कार्यान्वयन लिखना चाहते थे, तो "InvokeDebuggerOrDie (अपवाद)" जैसा कुछ होगा;

पुनरारंभ

RestartBind और RestartCase

RestartBind और RestartCase, HandlerBind और HandlerCase के समान हैं, इस अंतर के साथ कि वे रीस्टैक स्टैक के साथ काम करते हैं और प्रतिनिधि-हैंडलर को अपवाद प्रकार नहीं, बल्कि स्ट्रिंग और रिस्टार्ट नाम को मैप करते हैं।

 public delegate object RestartBindCallback(object param); public delegate T RestartCaseCallback<T>(object param); public static T RestartBind<T>(string name, RestartBindCallback restart, HandlerBody<T> body) { if (null == name) throw new ArgumentNullException("name"); if (null == restart) throw new ArgumentNullException("restart"); if (null == body) throw new ArgumentNullException("body"); Thread currentThread = Thread.CurrentThread; var clusters = _restartStacks.GetOrCreateValue(currentThread); clusters.Push(Tuple.Create(name, restart)); try { return body(); } finally { clusters.Pop(); } } public static T RestartCase<T>(string name, RestartCaseCallback<T> restart, HandlerBody<T> body) { if (null == name) throw new ArgumentNullException("name"); if (null == restart) throw new ArgumentNullException("restart"); if (null == body) throw new ArgumentNullException("body"); var unwindTag = new UnwindTag<T>(); RestartBindCallback restartCallback = (param) => { unwindTag.Value = restart(param); throw unwindTag; }; try { return RestartBind(name, restartCallback, body); } catch (UnwindTag<T> e) { if (e == unwindTag) { return e.Value; } else throw; } }

FindRestart और InvokeRestart

FindRestart और InvokeRestart, बदले में, सिग्नल विधि के समान हैं - पहला फ़ंक्शन वर्तमान थ्रेड के संबंधित स्टैक में नाम से पुनरारंभ होता है, और दूसरा न केवल इसे ढूंढता है, बल्कि तुरंत इसे शुरू करता है।

 public static RestartBindCallback FindRestart(string name, bool throwOnError) { if (null == name) throw new ArgumentNullException("name"); Thread currentThread = Thread.CurrentThread; var clusters = _restartStacks.GetOrCreateValue(currentThread); var i = clusters.GetEnumerator(); while (i.MoveNext()) { var restartName = i.Current.Item1; var restart = i.Current.Item2; if (name == restartName) return restart; } if (throwOnError) throw new RestartNotFoundException(name); else return null; } public static object InvokeRestart(string name, object param) { var restart = FindRestart(name, true); return restart(param); }

ComputeRestarts

ComputeRestarts बस वर्तमान में स्थापित सभी पुनरारंभों की एक सूची देता है - यह उपयोगी हो सकता है, उदाहरण के लिए, एक अपवाद हैंडलर के लिए ताकि, जब बुलाया जाए, यह किसी विशेष स्थिति के लिए एक उपयुक्त पुनरारंभ चुन सकता है।

 public static IEnumerable<Tuple<string, RestartBindCallback>> ComputeRestarts() { var restarts = new Dictionary<string, RestartBindCallback>(); Thread currentThread = Thread.CurrentThread; var clusters = _restartStacks.GetOrCreateValue(currentThread); return clusters.AsEnumerable(); }

UnwindProtect

अनविंडप्रोटेक्ट का हमारा कार्यान्वयन बस एक कोशिश-आखिर ब्लॉक को लपेटता है।

 public static T UnwindProtect<T>(HandlerBody<T> body, params Action[] actions) { if (null == body) throw new ArgumentNullException("body"); if (null == actions) actions = new Action[0]; try { return body(); } finally { foreach (var a in actions) a(); } }

अंत में, उपयोग के कुछ उदाहरण।

हैंडलरबाइंड का उपयोग एक फ़ंक्शन के साथ जो अपवाद का संकेत देता है।
```
 static int DivSignal(int x, int y) { if (0 == y) { Conditions.Signal(new DivideByZeroException()); return 0; } else return x / y; } 
```
```
 int r = Conditions.HandlerBind( typeof(DivideByZeroException), (e) => { Console.WriteLine("Entering handler callback"); }, () => { Console.WriteLine("Entering HandlerBind with DivSignal"); var rv = DivSignal(123, 0); Console.WriteLine("Returning {0} from body", rv); return rv; }); Console.WriteLine("Return value: {0}\n", r); 
```
यहाँ DivSignal फ़ंक्शन, शून्य के बराबर एक विभाजक के साथ, एक ऐसी स्थिति का संकेत देता है जो उत्पन्न हुई है, लेकिन फिर भी, यह इसके साथ "सामना" करता है (शून्य लौटता है)। इस मामले में, न तो हैंडलर और न ही फ़ंक्शन कार्यक्रम के सामान्य पाठ्यक्रम को बाधित करता है।
कंसोल का आउटपुट निम्नानुसार है:
```
 Entering HandlerBind with DivSignal Entering handler callback Returning 0 from body Return value: 0 
```
त्रुटि के माध्यम से त्रुटि की रिपोर्ट करने वाले फ़ंक्शन के साथ हैंडलरकैस और अनविंडप्रोक्ट का उपयोग करना।
```
 static int DivError(int x, int y) { if (0 == y) Conditions.Error(new DivideByZeroException()); return x / y; } 
```
```
 int r = Conditions.HandlerCase( typeof(DivideByZeroException), (e) => { Console.WriteLine("Entering handler callback"); Console.WriteLine("Returning 0 from handler"); return 0; }, () => { Console.WriteLine("Entering HandlerCase with DivError and UnwindProtect"); return Conditions.UnwindProtect( () => { Console.WriteLine("Entering UnwindProtect"); var rv = DivError(123, 0); Console.WriteLine("This line should not be printed"); return rv; }, () => { Console.WriteLine("UnwindProtect exit point"); }); }); Console.WriteLine("Return value: {0}\n", r); 
```
इस मामले में, DivError फ़ंक्शन एक अपवाद फेंकता है, लेकिन हैंडलर इसे पकड़ता है, स्टैक को स्पिन करता है, और इसके मूल्य को वापस करता है (इस मामले में, 0)। जैसा कि स्टैक अनडिंड करता है, गणना प्रवाह अनविंडप्रोटेक्ट से गुजरता है।
यह उदाहरण, दूसरों के विपरीत, हमेशा की कोशिश, पकड़ने और अंत में फिर से लिखा जा सकता है।
कंसोल आउटपुट:
```
 Entering HandlerCase with DivError and UnwindProtect Entering UnwindProtect Entering handler callback Returning 0 from handler UnwindProtect exit point Return value: 0 
```
हैंडलरबाइंड का उपयोग एक फ़ंक्शन के साथ जिसमें एक पुनरारंभ स्थापित है।
```
 static int DivRestart(int x, int y) { return Conditions.RestartCase( "ReturnValue", (param) => { Console.WriteLine("Entering restart ReturnValue"); Console.WriteLine("Returning {0} from restart", param); return (int)param; }, () => { Console.WriteLine("Entering RestartCase"); return DivError(x, y); }); } 
```
DivRestart ने “ReturnValue” नामक एक पुनरारंभ को सेट किया, जो सक्रिय होने पर, बस (पैरा) पैरामीटर के माध्यम से इसे पास किए गए मान को लौटाता है। RestartCase का शरीर पिछले उदाहरण में वर्णित DivError को उठाता है।
```
 int r = Conditions.HandlerBind( typeof(DivideByZeroException), (e) => { Console.WriteLine("Entering handler callback"); Console.WriteLine("Invoking restart ReturnValue with param = 0"); Conditions.InvokeRestart("ReturnValue", 0); }, () => { Console.WriteLine("Entering HandlerBind with DivRestart"); return DivRestart(123, 0); }); Console.WriteLine("Return value: {0}", r); 
```
हैंडलरबाइंड में स्थापित हैंडलर, जिसे कॉल किया जाता है, एक रिस्टार्ट "रिटर्नवैल्यू" की खोज करता है और नंबर 0 को पैरामीटर में पास करता है, उसके बाद "रिटर्नवैल्यू" सक्रिय हो जाता है, स्टैक को उसके स्तर तक फैला देता है, और DivRestart में सेट रिस्टार्टकैसे से उसी नंबर को लौटाता है, जैसा कि ऊपर देखा गया है।
निष्कर्ष:
```
 Entering HandlerBind with DivRestart Entering RestartCase Entering handler callback Invoking restart ReturnValue with param = 0 Entering restart ReturnValue Returning 0 from restart Return value: 0 
```

पुस्तकालय का पूरा स्रोत कोड और उदाहरण github: github.com/Lovesan/ConditionSystem पर उपलब्ध है

C # में सामान्य लिस्प स्थिति प्रणाली को लागू करना