🧙🏻 ⬛️ 👩🏽‍🍳 TPL + DLR = बहुस्तरीय स्क्रिप्टिंग 🐉 💥 🖌️

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

समस्या का बयान

इसलिए, मैं कई स्क्रिप्ट्स को अतुल्यकालिक या कुछ विशिष्ट थ्रेड पर चलाने का अवसर चाहता हूं। ऐसा करने के लिए, मुझे एक निश्चित सेवा की आवश्यकता है जो निम्नलिखित कार्यों के लिए जिम्मेदार होगी:

स्क्रिप्टिंग के साथ काम के कार्यों के लिए लिंक संग्रहीत करना
एक विशिष्ट स्क्रिप्ट कार्य को रोकने का अनुरोध
कार्य स्थिति ट्रैकिंग
कंसोल के लिए लॉगिंग आउटपुट (Stdout और Stderr)
प्रसारण घटना द्वारा कंसोल को पाठ आउटपुट की सूचना

सामान्य तौर पर, कुछ इस तरह

वहां क्या दर्शाया गया है? रूट नोड - " IRE.Instance " - एक सिंगलटन है जो स्क्रिप्ट के काम को समन्वित करने के लिए जिम्मेदार बहुत सेवा की भूमिका निभाएगा। ऐसा करने के लिए, RunScriptWithScheduler और RunScriptAsync फ़ंक्शन के माध्यम से जोड़े गए प्रत्येक कार्य के लिए प्रविष्टियों के साथ एक शब्दकोश एक एकल उदाहरण में संग्रहीत किया जाएगा। जैसा कि नाम से पता चलता है, ये कार्य अनुसूचक द्वारा अलग-अलग होंगे, जिनके नियंत्रण में कार्य शुरू किया जाएगा। "RunScriptWithScheduler" का उपयोग करना, उदाहरण के लिए, GUI थ्रेड पर कार्य चलाना संभव होगा। " WriteMessage " और " WriteError " विधियाँ हर जगह से उपलब्ध होंगी (लिपियों से) और संदेश लॉग में आउटपुट के लिए अभिप्रेत है। स्क्रिप्ट के किनारे पर, सेवा लॉग में पाठ को पुनर्निर्देशित करने के लिए मानक आउटपुट विधियों को कंसोल पर ओवरराइड करना संभव होगा।
सेवा कार्य शब्दकोश में प्रविष्टि क्या होगी? कुंजी एक अद्वितीय GUID है जो रनिंग स्क्रिप्ट की पहचान करेगी। इस GUID को उस पार्टी में आसानी से स्थानांतरित किया जा सकता है जिसने स्क्रिप्ट को चलाने के लिए अनुरोध किया है, और स्क्रिप्ट के संदर्भ में ही एम्बेडेड है। रेकॉर्ड वैल्यू को कम से कम कैंसिलेशनट्यूकेन सोर्स और टास्क के संदर्भ में स्टोर करना चाहिए। रद्द करने के लिए, जिसके साथ टास्क स्क्रिप्ट बनाई गई है, आपको उस कार्य को इंगित करने की अनुमति देगा, जिसे आपको किसी भी समय राउंड ऑफ करना चाहिए। टास्क के लिए एक लिंक ही हमें इस पर कंटीन्यूएशन को टांगने की अनुमति देगा (मैंने विस्तार से यहां टीपीएल का वर्णन नहीं किया है)।

IRE सेवा

शायद मैं इंजन के कोर के विवरण के साथ शुरू करूँगा, अर्थात्, एक सिंगलटन के रूप में बनाई गई सेवा। सिंगलटन कार्यान्वयन MSDN से लिया गया है। JAVA पर विभिन्न सिंगलटन कार्यान्वयन के एक विस्तृत विस्तृत विश्लेषण की एक कड़ी भी है। मैं अत्यधिक पढ़ने की सलाह देता हूं अगर किसी ने अभी तक इसे नहीं पढ़ा है।
इसलिए, मैंने इस सेवा को बहु-थ्रेडेड "डबल-चेक्ड लॉकिंग" सिंगलटन के रूप में लागू किया। आधार कार्यान्वयन कोड कुछ इस प्रकार होगा:

सिंगलटन ने कोड टिप्पणी की

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using IronRuby; using Microsoft.Scripting; using Microsoft.Scripting.Hosting; using System.IO; using System.Threading.Tasks; using System.Diagnostics; using Microsoft.Scripting.Runtime; namespace IREngine { public sealed class IRE { #region Singleton private static volatile IRE _instance; private static readonly object SyncRoot = new Object(); private IRE() { //     //        IRE.Instance //  ,       -  ( , )   // var instance = IRE.Instance; } public static IRE Instance { get { if (_instance == null) { lock (SyncRoot) { if (_instance == null) _instance = new IRE(); } } return _instance; } } #endregion #region Consts //     #endregion #region Fields //     #endregion #region Properties //      #endregion #region Private Methods //       #endregion #region Public Methods //        #endregion } }

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

TPL का उपयोग करने के बारे में संक्षेप में

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

आउटपुट बफर में बदलाव के लिए कार्रवाई की जाँच
आउटपुट बफ़र की जाँच करते समय एक्शन एरर हैंडलिंग
त्रुटि बफ़र में परिवर्तन के लिए क्रिया जाँच
त्रुटि बफर की जाँच करते समय कार्रवाई त्रुटि से निपटने
सार्वजनिक विधि जो कार्य निष्पादित करने के लिए टास्क इंस्टेंसेस बनाएगी

आइए सिंगल्सटन के निजी कंस्ट्रक्टर में क्रियाओं को आरंभ करें

प्रारंभिक क्रिया

 private IRE() { //     Ruby _outStringBuilder = new StringBuilder(); _errStringBuilder = new StringBuilder(); _outWatchAction = () => { int i = 0; while (IsConsoleOutputWatchingEnabled) { string msg = string.Format("***\t_outWatchTask >> tick ({0})\t***", i++); Debug.WriteLine(msg); WriteMessage(msg); Task.Factory.CancellationToken.ThrowIfCancellationRequested(); int currentLength = OutputBuilder.Length; if (OutputUpdated != null && currentLength != _lastOutSize) { OutputUpdated.Invoke(_outWatchTask, new StringEventArgs(OutputBuilder. ToString(_lastOutSize, currentLength - _lastOutSize))); _lastOutSize = currentLength; } Thread.Sleep(TIME_BETWEEN_CONSOLE_OUTPUT_UPDATES); } }; _outWatchExcHandler = (t) => { if (t.Exception == null) return; Instance.WriteError( string.Format( "!!!\tException raised in Output Watch Task\t!!!\n{0}", t.Exception.InnerException.Message)); }; _errWatchAction = () => { int i = 0; while (IsConsoleErrorWatchingEnabled) { string msg = string.Format("***\t_errWatchTask >> tick ({0})\t***", i++); Debug.WriteLine(msg); WriteError(msg); Task.Factory.CancellationToken.ThrowIfCancellationRequested(); int currentLength = ErrorBuilder.Length; if (ErrorUpdated != null && currentLength != _lastErrSize) { ErrorUpdated.Invoke(_errWatchTask, new StringEventArgs(ErrorBuilder. ToString(_lastErrSize, currentLength - _lastErrSize))); _lastErrSize = currentLength; } Thread.Sleep(TIME_BETWEEN_CONSOLE_OUTPUT_UPDATES); } }; _errWatchExcHandler = (t) => { if (t.Exception == null) return; Instance.WriteError( string.Format( "!!!\tException raised in Error Watch Task\t!!!{0}", t.Exception.InnerException.Message)); }; }

नीचे आवश्यक गुणों, स्थिरांक और निजी क्षेत्रों की घोषणाएं हैं।

फ़ील्ड्स, गुण, स्थिरांक आरंभीकरण

 #region Consts public readonly int TIME_BETWEEN_CONSOLE_OUTPUT_UPDATES = 1000; #endregion #region Fields private bool _outWatchEnabled; private bool _errWatchEnabled; private Task _outWatchTask; private readonly CancellationTokenSource _outWatchTaskToken = new CancellationTokenSource(); private int _lastOutSize = 0; private Task _errWatchTask; private readonly CancellationTokenSource _errWatchTaskToken = new CancellationTokenSource(); private int _lastErrSize = 0; private readonly StringBuilder _outStringBuilder; private readonly StringBuilder _errStringBuilder; private readonly Action _outWatchAction; private readonly Action<Task> _outWatchExcHandler; private readonly Action _errWatchAction; private readonly Action<Task> _errWatchExcHandler; private readonly CancellationTokenSource _scriptsToken = new CancellationTokenSource(); #endregion #region Properties public StringBuilder OutputBuilder { get { lock (SyncRoot) { return _outStringBuilder; } } } public StringBuilder ErrorBuilder { get { lock (SyncRoot) { return _errStringBuilder; } } } public bool IsConsoleOutputWatchingEnabled { get { lock (SyncRoot) { return _outWatchEnabled; } } set { lock (SyncRoot) { _outWatchEnabled = value; } } } public bool IsConsoleErrorWatchingEnabled { get { lock (SyncRoot) { return _errWatchEnabled; } } set { lock (SyncRoot) { _errWatchEnabled = value; } } } public event EventHandler<StringEventArgs> OutputUpdated; public event EventHandler<StringEventArgs> ErrorUpdated; #endregion

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

इवेंट हैंडलर कोड

 IRE.Instance.OutputUpdated += (s, args) => { string msg = string.Format("***\tIRE >> Out Updated callback\t***\nResult: {0}\n***\tEND\t***\n",args.Data); Debug.WriteLine(msg); var uiUpdateTask = Task.Factory.StartNew(() => { OutputLogList.Items.Add(msg); }, Task.Factory.CancellationToken, TaskCreationOptions.None, _uiScheduler); uiUpdateTask.Wait(); }; IRE.Instance.ErrorUpdated += (s, args) => { string msg = string.Format("!!!\tIRE >> Err Updated callback\t!!!\nResult: {0}\n!!!\tEND\t!!!\n", args.Data); Debug.WriteLine(msg); var uiUpdateTask = Task.Factory.StartNew(() => { ErrorLogList.Items.Add(msg); }, Task.Factory.CancellationToken, TaskCreationOptions.None, _uiScheduler); uiUpdateTask.Wait(); }; IRE.Instance.StartWatching();

यह कोड कंसोल आउटपुट बफर रिफ्रेश इवेंट की सदस्यता जोड़ता है। इसमें ध्यान देने वाली मुख्य बात " _uiScheduler " है। यह मुख्य विंडो के डिजाइनर में इसके (विंडोज़) शेड्यूलर के लिए बनाई गई एक कड़ी है। यह लिंक इस प्रकार बनाया गया है।

 public MainWindow() { InitializeComponent(); _uiScheduler = TaskScheduler.FromCurrentSynchronizationContext(); }

इस अनुसूचक के साथ बनाए गए सभी कार्यों को जीयूआई थ्रेड पर लॉन्च किया जाएगा, चाहे वे जिस भी थ्रेड पर स्थापित हों। ग्राफिकल इंटरफ़ेस तत्वों के लिए शॉर्ट सर्किट क्रॉस-थ्रेडिंग एक्सेस अपवाद का कारण नहीं होगा।
अब लाइन के बारे में " uiUpdateTask.Wait (); "। " कोशिश - पकड़ " में इस पंक्ति को फ्रेम करना वांछनीय है। टास्क के अंदर होने वाले सभी अपवादों को तुरंत उस थ्रेड में स्थानांतरित नहीं किया जाता है जिसने कार्य बनाया है। कॉलिंग थ्रेड में अपवादों को एक्सेस करने का एक तरीका वेट () फ़ंक्शन को कॉल करना है। आप कार्य में "निरंतरता" भी जोड़ सकते हैं और इसमें अपवाद पोस्ट कर सकते हैं। कोई फर्क नहीं पड़ता, लेकिन आपको अपवादों को संभालना चाहिए । अन्यथा, अपवाद को कॉलिंग थ्रेड में भेजा जाएगा जब "गारबेजकोलेक्टर" कार्य के लिए हो जाता है। यह किस बिंदु पर होगा अज्ञात है। इसलिए, एक आवेदन के लिए यह घातक हो सकता है।
इस मामले में, सादगी के लिए, मैंने " कोशिश - पकड़ " नहीं जोड़ा, लेकिन मैं बाद में इसे जोड़ दूंगा। अब यहाँ कोड काफी सरल है, लेकिन भविष्य में सब कुछ बदल सकता है।
अब यह कंसोल आउटपुट की निगरानी के लिए कार्य बनाने के लिए कोड प्रदान करने के लिए बना हुआ है।

 public void StartWatching() { StopWatching(); if (_outWatchTask != null) _outWatchTask.Wait(); if (_errWatchTask != null) _errWatchTask.Wait(); IsConsoleOutputWatchingEnabled = IsConsoleErrorWatchingEnabled = true; _outWatchTask = Task.Factory.StartNew(_outWatchAction, _outWatchTaskToken.Token); _outWatchTask.ContinueWith(_outWatchExcHandler, TaskContinuationOptions.OnlyOnFaulted); _errWatchTask = Task.Factory.StartNew(_errWatchAction, _errWatchTaskToken.Token); _errWatchTask.ContinueWith(_errWatchExcHandler, TaskContinuationOptions.OnlyOnFaulted); }

यहां सब कुछ सरल भी है। बस मामले में, हम ट्रैकिंग कार्यों को रोकते हैं (" स्टॉपवॉचिंग (); ")। इस फ़ंक्शन को कॉल करने से केवल " IsConsoleOutputWatchingEnabled " और " IsConsoleErrorWatchingEnabled " झंडे सेट होते हैं , और " कैंसलेशनटोकन " के माध्यम से स्टॉप को भी रोकता है। मैं खुद को सिर्फ एक टोकन तक सीमित कर सकता था। लेकिन सामान्य तौर पर, एक टोकन के माध्यम से रोक अनुरोध को आपातकालीन स्टॉप माना जाता है। यहां तक कि एक विशेष कार्य भी है " Task.Factory.CancellationToken.ThrowIfCancellationRested (); जिसका कॉल कार्य को अपवाद को फेंकने का कारण बनता है यदि टोकन के माध्यम से कार्य के निष्पादन के दौरान रद्द करने का अनुरोध प्राप्त होता है। यह उल्लेखनीय है कि इस फ़ंक्शन को कॉल करना और आम तौर पर रद्द करने की स्थिति की जांच करना। टोकन बहुत महंगा प्रक्रिया है। इसलिए, यह जितना संभव हो उतना कम करने के लिए वांछनीय है।
अगली बात जिस पर मैं ध्यान देना चाहता हूं वह है " _outWatchTask.ContinueWith (_outWatchExcHandler, TaskContinuationOptions.OnlyOnFaulted); "। यह कोड एक कार्य को तथाकथित "कंटिन्यूएशन" (निरंतरता) पर लटकाता है। इसके अलावा, निरंतरता " TaskContinuationOptions.OnlyOnFaulted " विकल्प के साथ बनाई गई है। इस तरह के एक निरंतरता को केवल तभी कहा जाता है यदि कार्य के "एग्रीगेटेड एक्ससेप्शन" में कम से कम एक अपवाद हो। सीधे शब्दों में कहें, यदि कोई कार्य सामान्य रूप से पूरा होता है, तो इस सीक्वल को अनदेखा किया जाएगा। यह भी ध्यान दिया जाना चाहिए कि कई अपवाद हो सकते हैं। आखिरकार, हम इस कार्य के भीतर नेस्टेड उप-मुखौटे बना सकते हैं। जब " जीसी " द्वारा नेस्टेड कार्यों को एकत्र किया जाता है, तो सभी अखंडित अपवाद उसी "एग्रीगेटेड एक्ससेप्शन" के रूप में माता-पिता के लिए पॉप हो जाएंगे। इस प्रकार, आप नेस्टेड अपवादों का एक पूरा पेड़ प्राप्त कर सकते हैं। इस अपवाद के पेड़ को एक सपाट सूची में बदलने के लिए एक विशेष विधि " एग्रीगेटेड एक्ससेप्शन.फ़्लैटन () " है।

स्क्रिप्टिंग बेसिक्स

अब बात करते हैं स्क्रिप्टिंग की ही। सबसे पहले, हमें एक "ScriptEngine" बनाने और उसमें हमारे एप्लिकेशन की आवश्यक .Net असेंबलियों को लोड करने की आवश्यकता है। यह बस किया जाता है:

 _defaultEngine = Ruby.CreateEngine((setup) => { setup.ExceptionDetail = true; }); _defaultEngine.Runtime.LoadAssembly(typeof(IRE).Assembly);

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

अतुल्यकालिक कोड कार्य स्क्रिप्ट जोड़ना

 public Guid RunScriptAsync(string code) { var scriptScope = _defaultEngine.CreateScope(); CompiledCode compiledCode = null; try { ScriptSource scriptSource = _defaultEngine.CreateScriptSourceFromString(code, SourceCodeKind.AutoDetect); var errListner = new ErrorSinkProxyListener(ErrorSink.Default); compiledCode = scriptSource.Compile(errListner); } catch (Exception ex) { WriteError(ex.Message); return Guid.Empty; } var action = new Action(() => compiledCode.Execute(scriptScope)); var tokenSource = new CancellationTokenSource(); var task = new Task(action, tokenSource.Token, TaskCreationOptions.LongRunning); var guid = Guid.NewGuid(); AddTask(guid, new TaskRecord { TokenSource = tokenSource, Task = task }); task.Start(); task.ContinueWith((t) => { // Actually we don't needed this due to "TaskContinuationOptions.OnlyOnFaulted" is set if (t.Exception == null) return; t.Exception.Flatten().Handle((ex) => { Instance.WriteError(t.Exception.InnerException.Message); return true; }); }, TaskContinuationOptions.OnlyOnFaulted); task.ContinueWith((t) => { Instance.RemoveTask(guid); }); return guid; } public void AddTask(Guid key, TaskRecord record) { _tasks.Add(key, record); } public void RemoveTask(Guid key) { _tasks.Remove(key); } public Task GetTask(Guid key) { return _tasks.ContainsKey(key) ? _tasks[key].Task : null; } public void RequestCancelation(Guid key) { var tokenSource = _tasks.ContainsKey(key) ? _tasks[key].TokenSource : null; if (tokenSource == null) return; tokenSource.Cancel(); }

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

उदाहरण का उपयोग करें

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

 <Window x:Class="IREngineTestBed.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="MainWindow" Height="350" Width="525"> <Grid> <Grid.ColumnDefinitions> <ColumnDefinition /> <ColumnDefinition /> </Grid.ColumnDefinitions> <Grid.RowDefinitions> <RowDefinition /> <RowDefinition Height="Auto"/> </Grid.RowDefinitions> <Button x:Name="StartButton" Content="Start" Grid.Row="1" Margin="5" Height="25" Click="StartButton_Click"/> <Button x:Name="StopButton" Content="Stop" Grid.Row="1" Grid.Column="1" Margin="5" Height="25" Click="StopButton_Click"/> <ListBox x:Name="OutputLogList" Grid.Column="0" Margin="5"/> <ListBox x:Name="ErrorLogList" Grid.Column="1" Margin="5"/> </Grid> </Window>

निष्कर्ष

विंडो में दो ListBox'a और दो बटन हैं। स्ट्रिंग्स को जोड़ने के खराब प्रदर्शन के कारण मैंने टेक्स्टब्लॉक का उपयोग लॉग्स को प्रदर्शित करने के लिए नहीं किया था (टेक्स्टब्लॉक। टेक्स्ट + = "कुछ स्ट्रिंग" - एक महान बुराई है, जैसा कि आप शायद जानते हैं)। लेकिन ListBoxes वास्तव में एक बुरा विचार है। बस पाठ की नकल न करें। सामान्य तौर पर, ListBox'y बस डाल प्रदर्शन के लिए (जल्दबाजी में)। भविष्य में मैं शायद RichTextBox को बदल दूंगा। उन्हें स्ट्रिंग वर्चुअलाइजेशन लगता है, और टेक्स्ट स्ट्रिंगबर्ल के साथ जुड़ने लगता है।
इसलिए, "स्टार्टबटन" बटन का उपयोग करके, कंसोल आउटपुट बफ़र्स और स्क्रिप्ट निष्पादन कार्यों की निगरानी के लिए कार्यों की शुरुआत की जाती है। बटन "स्टॉपबटन" - सब कुछ बंद हो जाता है।
यहाँ परीक्षण स्क्रिप्ट के लिए कोड है।

 #!ruby19 # encoding: utf-8 include IREngine class IRE def log(message) IRE.Instance.write_message message end def err(message) IRE.Instance.write_error message end end def log(message, is_err = false) IRE.Instance.log message unless is_err IRE.Instance.err message if is_err end 5.times{|i| log "Hello, Output! (from Ruby Async Task)" log "Hello, Error! (from Ruby Async Task)", true } raise "\n!!!\tBOOO! Catch super scaring exception from RUBY...\t!!!\n"

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

निष्कर्ष

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

आपका ध्यान के लिए धन्यवाद!

TPL + DLR = बहुस्तरीय स्क्रिप्टिंग

समस्या का बयान

IRE सेवा

TPL का उपयोग करने के बारे में संक्षेप में

स्क्रिप्टिंग बेसिक्स

उदाहरण का उपयोग करें

निष्कर्ष

निष्कर्ष

More articles: