निर्भरता प्रबंधन, घटनाओं, और प्रेक्षक और मध्यस्थ पैटर्न

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

निर्भरता प्रबंधन

आइए कथन के साथ शुरू करते हैं: यदि क्लास ए कक्षा बी पर निर्भर करता है, तो, व्यवहार को बदलने के बिना, आप कोड को फिर से लिख सकते हैं ताकि क्लास बी कक्षा ए पर निर्भर करता है या किसी अन्य वर्ग सी का परिचय देता है ताकि कक्षा ए और बी स्वतंत्र हो, और कक्षा C बंधेगा और A और B की कक्षाओं पर निर्भर करेगा।



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

class A { private readonly B _b; public A(B b) { _b = b; } public void Run() { _b.Print(); } } class B { public void Print() { Console.WriteLine(DateTime.Now.ToString()); } } public void Test() { var b = new B(); var a = new A(b); a.Run(); } 

इस प्रकार, क्लास ए कक्षा बी पर निर्भर करता है। इस निर्भरता को उलटने के लिए, सीधे प्रिंट पद्धति को कॉल करने के बजाय, हम एक घटना उत्पन्न करेंगे। अब क्लास ए को क्लास बी के बारे में कुछ नहीं पता है, और क्लास बी क्लास ए। ई। की घटना के लिए सदस्यता ले सकता है। वर्ग B वर्ग A पर निर्भर करेगा

 class A { public event EventHandler PrintRequested; public void Run() { PrintRequested.Invoke(this, EventArgs.Empty); } } class B { private readonly A _a; public B(A a) { _a = a; _a.PrintRequested += (s, e) => Print(); } public void Print() { Console.WriteLine(DateTime.Now.ToString()); } } public void Test() { var a = new A(); var b = new B(a); a.Run(); } 

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

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

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

 class A { public event EventHandler PrintRequested; public void Run() { PrintRequested.Invoke(this, EventArgs.Empty); } } class B { public void Print() { Console.WriteLine(DateTime.Now.ToString()); } } class C { public void Test() { var a = new A(); var b = new B(); a.PrintRequested += (s, e) => b.Print(); a.Run(); } } 

अब कक्षा ए और बी पूरी तरह से स्वतंत्र हैं, प्रत्येक अपना कार्य करता है और अन्य कक्षाओं के बारे में कुछ भी नहीं जानता है। वस्तुओं के बीच बातचीत का तर्क एक नए वर्ग में जाता है। केवल क्लास सी को पता है कि किस घटना के तहत और किन परिस्थितियों में क्लास बी तरीकों को बुलाया जाना चाहिए। इस प्रकार, क्लास सी एक मध्यस्थ बन जाता है।

सारांश: फाइटिंग सिस्टम जटिलता

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

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



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


ऑब्जर्वर और मध्यस्थ पैटर्न का उपयोग करते समय एक खतरनाक नुकसान परिपत्र संदर्भों की उपस्थिति है, जब एक ही वर्ग से घटनाओं, वस्तुओं की एक श्रृंखला से गुजरते हुए, उसी घटना की पीढ़ी का नेतृत्व फिर से होता है। इस समस्या को हल करना मुश्किल है और पैटर्न के उपयोग को काफी जटिल करता है।

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