डिस्पैचर का उपयोग करके प्रबंधित कोड से देशी पुस्तकालय को कॉल करना

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

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

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

कार्यान्वयन के विकल्प

पहला विकल्प जो मन में आता है वह है एक्शन क्लास की वस्तुओं की कतार का उपयोग:

ConcurrentQueue<Action> _actions; 

उसी समय, ग्राहक सूत्र इसमें निष्पादन तत्व जोड़ते हैं:

 _actions.Enqueue(() => { < > }); 

और लक्ष्य धागा प्राप्ति के क्रम में उन्हें निष्पादित करता है:

 Action action; if (_actions.TryDequeue()) { action(); } 

यह कार्यान्वयन विकल्प, निश्चित रूप से अस्तित्व का अधिकार है, लेकिन इस मामले में ललाट कार्यान्वयन संसाधन उपयोग और उत्पादकता के मामले में इष्टतम से बहुत दूर होगा, और अधिक उन्नत तकनीकों को विकास और परीक्षण के लिए बहुत अधिक समय की आवश्यकता होगी, और संभवतः एक साइकिल का आविष्कार होगा। इसलिए, यह आलेख .NET फ्रेमवर्क द्वारा प्रदान किए गए टूल का उपयोग करके समस्या को हल करने के लिए अधिक सुरुचिपूर्ण तरीके पर विचार करेगा। अर्थात्, System.Windows.Threading.Dispatcher, जो संभवतः ऊपर वर्णित विवरण के समान काम करता है और अनन्य ताले का उपयोग करता है।

कार्यान्वयन

मान लें कि हमारे पास एक बाहरी इन्वर्टफेस क्लास है जो एक इंटरफ़ेस को बाहरी लाइब्रेरी में लागू करता है, जिसके तरीकों को एक अलग आकार में बुलाया जाना चाहिए:

 internal static class ExternalInterface { public static void Method1() { throw new NotImplementedException(); } public static int Method2() { throw new NotImplementedException(); } public static int Method3() { throw new NotImplementedException(); } private static void ExternalMethod1() { //    Thread.Sleep(1000); } private static int ExternalMethod2() { //    Thread.Sleep(1000); return 1; } private static void ExternalMethod3() { //    Thread.Sleep(1000); } } 

जहाँ ExternalMethod1, ExternalMethod2, और ExternalMethod3 बाहरी पुस्तकालय के आयातित तरीके हैं, और Method1, Method2, और Method3 वर्ग की इंटरफ़ेस विधियाँ हैं जिनका एकमात्र कार्य एक ही आवंटित स्ट्रीम के संदर्भ में आयातित विधियों को निष्पादित करना है।
एक क्लाइंट क्लास भी है (सबसे सरल स्थिति में, कंसोल एप्लिकेशन का प्रोग्राम क्लास), जिसमें विभिन्न थ्रेड्स से एक्सटर्नल इंट्रोडक्शन विधियों को बुलाया जाता है:

 class Program { static void ThreadMethod1() { ExternalInterface.Method1(); } static void ThreadMethod2() { ExternalInterface.Method2(); } static void ThreadMethod3() { ExternalInterface.Method3(); } static void Main(string[] args){ } } 

अब चलो एक ही धागे में आयातित तरीकों पर कॉल को व्यवस्थित करने के लिए आगे बढ़ते हैं। सबसे पहले, इस संदर्भ में एक धारा बनाएं कि आयातित विधियों को कॉल किया जाएगा, और कॉल की प्रतीक्षा करने के लिए इसे तैयार करें:

 //     private static Thread _dispatchingThread; // Dispatcher      private static Dispatcher _dispatchObject; public static void Open() { //     _dispatchingThread = new Thread(DispatchingThreadMethod); _dispatchingThread.Start(); } private static void DispatchingThreadMethod() { Console.WriteLine(Thread.CurrentThread.ManagedThreadId); //  ,    // ... //  Dispatcher'  _dispatchObject = Dispatcher.CurrentDispatcher; //      Dispatcher.Run(); //  ,    // ... } 

अगला, हम लक्ष्य तत्व को निष्पादन तत्व के हस्तांतरण को सरल बनाते हैं:

 private void Dispatch(Action action) { if (_dispatchObject != null) { _dispatchObject.Invoke(action); } } 

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

 private void Dispatch(Action action) { if (_dispatchObject != null) { lock (_dispatchObject) { _dispatchObject.Invoke(action); } } } 

अब हम इंटरफ़ेस विधियों को लागू करते हैं:

 public static void Method1() { Dispatch(() => ExternalMethod1()); } public static int Method2() { int result = 0; Dispatch(() => { result = ExternalMethod2(); }); return result; } public static void Method3() { Dispatch(() => ExternalMethod3()); } 

The_dispatchingThread थ्रेड के सही समापन के लिए, बाहरी विधि वर्ग में एक और विधि जोड़ें:

 public static void Close() { _dispatchObject.InvokeShutdown(); } 

यह साबित करने के लिए कि सभी विधियों को एक ही थ्रेड में बुलाया जाएगा, निम्नलिखित कोड निष्पादित करें:

 static void Main(string[] args) { ExternalInterface.Open(); //       Dispatcher //     Thread.Sleep(1000); new Thread(ThreadMethod1).Start(); new Thread(ThreadMethod2).Start(); new Thread(ThreadMethod3).Start(); Console.ReadKey(); ExternalInterface.Close(); } 

परिणाम एक ही थ्रेड पहचानकर्ता का चार गुना मुद्रण होगा, जिसका अर्थ है कि सभी विधि कॉल एक थ्रेड के संदर्भ में किए गए थे।

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