🛴 🚫 🚿 प्रिज्म डेवलपर की गाइड - भाग 4, विकासशील मॉड्यूलर अनुप्रयोग 👾 ⏳ 👩🏿‍🤝‍👩🏽

सामग्री की तालिका
परिचय
प्रारम्भिक प्रिज्म अनुप्रयोग
घटकों के बीच निर्भरता का प्रबंधन
मॉड्यूलर अनुप्रयोग विकास
एमवीवीएम पैटर्न को लागू करना
उन्नत MVVM परिदृश्य
उपयोगकर्ता इंटरफ़ेस निर्माण
उपयोगकर्ता इंटरफ़ेस दिशानिर्देश
नेविगेशन
दृश्य-आधारित नेविगेशन
शिथिल युग्मित घटकों के बीच पारस्परिक क्रिया

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

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

निम्नलिखित चित्रण एक मॉड्यूलर अनुप्रयोग डिज़ाइन दिखाता है।

मॉड्यूलर आवेदन

मॉड्यूलर अनुप्रयोगों के निर्माण से लाभ

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

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

मॉड्यूलर अनुप्रयोग विकास के लिए प्रिज्म समर्थन

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

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

मूल अवधारणाएँ

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

IModule : मॉड्यूलर अनुप्रयोगों का निर्माण खंड

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

 public class MyModule : IModule { public void Initialize() { //    . } }

टिप्पणी
IModule द्वारा प्रदान किए गए आरंभीकरण तंत्र का उपयोग करने के बजाय, स्टॉक ट्रेडर आरआई विचारों, सेवाओं और प्रकारों को पंजीकृत करने के लिए एक घोषणात्मक, विशेषता-आधारित दृष्टिकोण का उपयोग करता है।

मॉड्यूल जीवन भर

प्रिज्म में मॉड्यूल लोडिंग प्रक्रिया में निम्नलिखित शामिल हैं:

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

निम्नलिखित चित्रण मॉड्यूल लोडिंग प्रक्रिया को दर्शाता है।

मॉड्यूल कैटलॉग

ModuleCatalog में उन मॉड्यूल के बारे में जानकारी होती है जो एप्लिकेशन उपयोग कर सकते हैं। एक निर्देशिका अनिवार्य रूप से ModuleInfo कक्षाओं का एक संग्रह है। प्रत्येक मॉड्यूल ModuleInfo वर्ग द्वारा वर्णित है, जो मॉड्यूल का नाम, प्रकार और स्थान संग्रहीत करता है। ModuleCatalog उदाहरणों के साथ ModuleCatalog को ModuleCatalog करने के लिए कई विशिष्ट दृष्टिकोण हैं:

कोड में मॉड्यूल का पंजीकरण।
XAML में रजिस्टरिंग मॉड्यूल।
कॉन्फ़िगरेशन फ़ाइल में मॉड्यूल का पंजीकरण (केवल WPF में)।
डिस्क पर स्थानीय निर्देशिका में मॉड्यूल का पता लगाना (केवल WPF में)।

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

मॉड्यूल लोडिंग समय का प्रबंधन

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

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

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

आवेदन के साथ मॉड्यूल का एकीकरण

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

मॉड्यूल के Initialize मेथड का प्रयोग करें, बाकी एप्लिकेशन के साथ मॉड्यूल को एकीकृत करने के लिए। आपके ऐसा करने का तरीका एप्लिकेशन की संरचना और मॉड्यूल की सामग्री पर निर्भर करेगा। निम्नलिखित सामान्य कदम हैं जिन्हें आपके एप्लिकेशन में मॉड्यूल को एकीकृत करने के लिए लिया जाना चाहिए:

मॉड्यूल में निहित विचारों को एप्लिकेशन की नेविगेशन संरचना में जोड़ें। खोज या विचारों के इंजेक्शन का उपयोग करके समग्र अनुप्रयोग का UI बनाते समय यह एक सामान्य कदम है।
एप्लिकेशन या सेवा स्तर की घटनाओं के लिए सदस्यता लें।
एप्लिकेशन निर्भरता इंजेक्शन कंटेनर में साझा सेवाओं को पंजीकृत करें।

मॉड्यूल के बीच संचार

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

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

निर्भरता इंजेक्शन और मॉड्यूलर अनुप्रयोग

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

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

MEF (जो अब .NET फ्रेमवर्क 4 और सिल्वरलाइट 4 का हिस्सा है) आपको निर्भरता इंजेक्शन-आधारित संरचना का समर्थन करके एक्स्टेंसिबल एप्लिकेशन बनाने की अनुमति देता है, और अन्य कार्यों को भी प्रदान करता है जो मॉड्यूलर अनुप्रयोग विकास का समर्थन करते हैं। यह एप्लिकेशन को रनटाइम पर घटकों का पता लगाने और फिर उन्हें एप्लिकेशन में एकीकृत करने की अनुमति देता है। एमईएफ विस्तार और रचना के लिए महान अवसर प्रदान करता है। इनमें असेंबली और टाइप डिटेक्शन, डिपेंडेंसी रेजोल्यूशन, डिपेंडेंसी इंजेक्शन और असेंबलिंग और एक्सएपी फाइलें लोड करने की कुछ विशेषताएं शामिल हैं। प्रिज्म इस तरह के MEF कार्यों के उपयोग का समर्थन करता है:

मॉड्यूल के प्रकार उनकी XAP फ़ाइलों के स्थान के साथ एसोसिएशन।
XAML के माध्यम से और WPF और सिल्वरलाइट के लिए कोड में मॉड्यूल रजिस्टर करना।
WPF के लिए कॉन्फ़िगरेशन फ़ाइलों और स्कैन की गई निर्देशिकाओं के माध्यम से मॉड्यूल का पंजीकरण।
ट्रैकिंग मॉड्यूल लोड की स्थिति।
मॉड्यूल के लिए कस्टम घोषणात्मक मेटाडेटा।

प्रमुख निर्णय

पहला निर्णय जो आपको करना चाहिए वह यह है कि क्या आप एक मॉड्यूलर एप्लिकेशन विकसित करना चाहते हैं। मॉड्यूलर अनुप्रयोगों के निर्माण के कई फायदे हैं, जैसा कि पिछले भाग में चर्चा की गई है, लेकिन अतिरिक्त समय और प्रयास भी हैं जो आपको इन लाभों को प्राप्त करने के लिए करने होंगे। यदि आप अभी भी एक मॉड्यूलर अनुप्रयोग विकसित करने का निर्णय लेते हैं, तो विचार करने के लिए कुछ और चीजें हैं:

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

निम्नलिखित अनुभाग इन समाधानों का विस्तार करते हैं।

मॉड्यूल में आवेदन का पृथक्करण

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

एक मॉड्यूल को संबंधित कार्यक्षमता की एक श्रृंखला को संक्षिप्त करना होगा और विभिन्न जिम्मेदारियों का एक सेट होना चाहिए। एक मॉड्यूल एक आवेदन के ऊर्ध्वाधर खंड या सेवाओं की एक क्षैतिज परत का प्रतिनिधित्व कर सकता है। बड़े अनुप्रयोगों में दोनों प्रकार के मॉड्यूल होने की संभावना है।

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

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

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

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

परियोजनाओं और मॉड्यूल के अनुपात का निर्धारण

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

XAP और मॉड्यूल फैक्टरिंग

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

कुछ कारक जो आपकी पसंद को प्रभावित करते हैं चाहे एक XAP फ़ाइल में कई मॉड्यूल शामिल करें या उन्हें विभाजित करें:

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

प्रत्येक एक्सएपी में कई बार एक ही विधानसभाओं को लोड करने से बचने के लिए, दो दृष्टिकोण हैं जिनका उपयोग किया जा सकता है:

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

ढीली युग्मन प्राप्त करने के लिए निर्भरता इंजेक्शन का उपयोग करें

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

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

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

बूटस्ट्रैपर मॉड्यूल इनिशियलाइज़ेशन प्रक्रिया शुरू करता है, और माड्यूलर लोडर लोड और इनिशियलाइज़ करता है OrdersModule।
प्रारंभिक चरण में OrdersModule, यह OrdersRepositoryकंटेनर में पंजीकृत होता है।
मॉड्यूल लोडर लोड करता है CustomersModule। मॉड्यूल के लोडिंग ऑर्डर को उनके मेटाडेटा के आधार पर निर्धारित किया जा सकता है।
CustomersModule CustomerViewModel , . CustomerViewModel OrdersRepository ( ) . , , OrdersModule . CustomerViewModel OrderRepository .

टिप्पणी
, , OrderRespository ( IOrderRepository ), , , , . , CustomersModule OrdersModule .

ध्यान दें कि दोनों मॉड्यूल निर्भरता इंजेक्शन कंटेनर पर एक अंतर्निहित निर्भरता है। यह निर्भरता बूटलोडर में मॉड्यूल निर्माण के दौरान पेश की जाती है।

आधार परिदृश्य

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

मॉड्यूल परिभाषा;

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

 public class MyModule : IModule { public void Initialize() { //  . } }

टिप्पणी
पूरे आवेदन में मॉड्यूल नाम अद्वितीय होने चाहिए।

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

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

पंजीकरण और मॉड्यूल की पहचान

अनुप्रयोग लोड कर सकने वाले मॉड्यूल को मॉड्यूल निर्देशिका में परिभाषित किया गया है। प्रिज्म मॉड्यूल लोडर मॉड्यूल कैटलॉग का उपयोग यह निर्धारित करने के लिए करता है कि कौन से मॉड्यूल डाउनलोड के लिए उपलब्ध हैं, उन्हें कब लोड करना है और उन्हें किस क्रम में लोड किया जाना चाहिए।

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

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

कोड में मॉड्यूल का पंजीकरण

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

 protected override void ConfigureModuleCatalog() { Type moduleCType = typeof(ModuleC); ModuleCatalog.AddModule( new ModuleInfo() { ModuleName = moduleCType.Name, ModuleType = moduleCType.AssemblyQualifiedName, }); }

पिछले उदाहरण में, शेल सीधे मॉड्यूल को संदर्भित करता है, इस प्रकार मॉड्यूल वर्गों के प्रकार का निर्धारण करता है जो विधि कॉल में उपयोग किए जा सकते हैं AddModule। यही कारण है कि यह उदाहरण typeof(Module)निर्देशिका में मॉड्यूल जोड़ने के लिए उपयोग करता है।

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

कोड में दृढ़ संकल्प मॉड्यूल सूची का एक और उदाहरण देखने के लिए उल्लेख StockTraderRIBootstrapper.csकरने के लिए स्टॉक व्यापारी आरआई ।

टिप्पणी
Bootstrapper CreateModuleCatalog , ModuleCatalog . , ModuleCatalog , .

XAML

आप मॉड्यूल निर्देशिका को XAML फ़ाइल में घोषित रूप से परिभाषित कर सकते हैं। XAML फ़ाइल निर्धारित करती है कि कौन सा मॉड्यूल कैटलॉग क्लास बनाना है और कौन सा मॉड्यूल इसे जोड़ना है। आमतौर पर .xamlआपके शेल प्रोजेक्ट में एक संसाधन के रूप में एक फ़ाइल जोड़ी जाती है। मॉड्यूल निर्देशिका को बूटलोडर में विधि को कॉल करके बनाया जाता है CreateFromXaml। एक तकनीकी दृष्टिकोण से, यह दृष्टिकोण ModuleCatalogकोड में परिभाषा के समान है , क्योंकि XAML फ़ाइल केवल वस्तुओं के पदानुक्रम को तुरंत परिभाषित करती है।

निम्न कोड उदाहरण एक XAML फ़ाइल दिखाता है जो एक मॉड्यूल निर्देशिका को परिभाषित करता है।

 <Modularity:ModuleCatalog xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:sys="clr-namespace:System;assembly=mscorlib" xmlns:Modularity="clr-namespace:Microsoft.Practices.Prism.Modularity;assembly=Microsoft.Practices.Prism"> <Modularity:ModuleInfoGroup Ref="ModuleB.xap" InitializationMode="WhenAvailable"> <Modularity:ModuleInfo ModuleName="ModuleB" ModuleType="ModuleB.ModuleB, ModuleB, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" /> </Modularity:ModuleInfoGroup> <Modularity:ModuleInfoGroup InitializationMode="OnDemand"> <Modularity:ModuleInfo Ref="ModuleE.xap" ModuleName="ModuleE" ModuleType="ModuleE.ModuleE, ModuleE, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" /> <Modularity:ModuleInfo Ref="ModuleF.xap" ModuleName="ModuleF" ModuleType="ModuleF.ModuleF, ModuleF, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" > <Modularity:ModuleInfo.DependsOn> <sys:String>ModuleE</sys:String> </Modularity:ModuleInfo.DependsOn> </Modularity:ModuleInfo> </Modularity:ModuleInfoGroup> <!--      --> <Modularity:ModuleInfo Ref="ModuleD.xap" ModuleName="ModuleD" ModuleType="ModuleD.ModuleD, ModuleD, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" /> </Modularity:ModuleCatalog>

टिप्पणी
ModuleInfoGroupsएक ही .xap फ़ाइल या असेंबली में समूह मॉड्यूल के लिए एक सुविधाजनक तरीका प्रदान करते हैं, उसी तरीके से आरंभ किया जाता है, या केवल एक ही समूह में मॉड्यूल पर निर्भरता होती है। मॉड्यूल के बीच निर्भरता को मॉड्यूल के भीतर परिभाषित किया जा सकता है ModuleInfoGroup, हालांकि, विभिन्न लोगों में मॉड्यूल के बीच निर्भरता निर्दिष्ट करना संभव नहीं है ModuleInfoGroups। मॉड्यूल समूहों में मॉड्यूल डालना वैकल्पिक है। समूह के लिए जो गुण सेट किए गए हैं, वे सभी मॉड्यूल पर लागू होंगे। ध्यान दें कि मॉड्यूल एक समूह में न होकर भी पंजीकृत हो सकते हैं।

कक्षा में, Bootstrapperआपको संकेत करना चाहिए कि XAML फ़ाइल के लिए स्रोत है ModuleCatalog, जैसा कि नीचे दिखाया गया है।

 protected override IModuleCatalog CreateModuleCatalog() { return ModuleCatalog.CreateFromXaml( new Uri("/MyProject.Silverlight;component/ModulesCatalog.xaml", UriKind.Relative)); }

कॉन्फ़िगरेशन फ़ाइल का उपयोग करके मॉड्यूल रजिस्टर करना

WPF में, किसी फ़ाइल में मॉड्यूल जानकारी निर्दिष्ट करना संभव है App.config। इस दृष्टिकोण का लाभ यह है कि यह फ़ाइल एप्लिकेशन में संकलित नहीं होती है। यह एप्लिकेशन को पुनः स्थापित किए बिना रनटाइम पर मॉड्यूल को जोड़ना या निकालना आसान बनाता है।

निम्न कोड कॉन्फ़िगरेशन फ़ाइल को दिखाता है जो मॉड्यूल निर्देशिका को परिभाषित करता है। यदि आप चाहते हैं कि मॉड्यूल स्वचालित रूप से लोड हो, तो स्थापित करें startupLoaded="true"।

  <modules> <module assemblyFile="ModularityWithUnity.Desktop.ModuleE.dll" moduleType="ModularityWithUnity.Desktop.ModuleE, ModularityWithUnity.Desktop.ModuleE, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" moduleName="ModuleE" startupLoaded="false" /> <module assemblyFile="ModularityWithUnity.Desktop.ModuleF.dll" moduleType="ModularityWithUnity.Desktop.ModuleF, ModularityWithUnity.Desktop.ModuleF, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" moduleName="ModuleF" startupLoaded="false"> <dependencies> <dependency moduleName="ModuleE"/> </dependencies> </module> </modules>

टिप्पणी
भले ही आपकी असेंबली वैश्विक असेंबली कैश में हों या एप्लिकेशन के समान फ़ोल्डर में, एक विशेषता की आवश्यकता होती है assemblyFile। विशेषता का उपयोग करने moduleTypeके लिए सही करने के लिए मैप करने के IModuleTypeLoaderलिए किया जाता है।

Bootstrapperएप्लिकेशन क्लास में , आपको यह निर्दिष्ट करना होगा कि कॉन्फ़िगरेशन फ़ाइल किसके लिए स्रोत है ModuleCatalog। ऐसा करने के लिए, ConfigurationModuleCatalogनिम्न कोड में दिखाए गए अनुसार कक्षा का उपयोग करें ।

 protected override IModuleCatalog CreateModuleCatalog() { return new ConfigurationModuleCatalog(); }

टिप्पणी
आप अभी भी ConfigurationModuleCatalogकोड में मॉड्यूल जोड़ सकते हैं । आप इसका उपयोग कर सकते हैं, उदाहरण के लिए, यह सुनिश्चित करने के लिए कि आपके एप्लिकेशन के कामकाज के लिए मॉड्यूल मॉड्यूल निर्देशिका में जोड़े गए हैं।

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

स्थानीय निर्देशिका में मॉड्यूल का पता लगाना

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

 protected override IModuleCatalog CreateModuleCatalog() { return new DirectoryModuleCatalog() {ModulePath = @".\Modules"}; }

टिप्पणी
यह विशेषता सिल्वरलाइट में समर्थित नहीं है क्योंकि सिल्वरलाइट सुरक्षा मॉडल आपको फ़ाइल सिस्टम से असेंबलियों को लोड करने की अनुमति नहीं देता है।

लोड हो रहा है मॉड्यूल

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

मॉड्यूल प्रारंभिक

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

. , , .
. / , . Initialize , . , , , . , . , MenuService ( ), Initialize – , .
टिप्पणी
. , Initialize , . , . , , , «» .
. , Unity MEF, . , .

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

कोड में निर्भरता को परिभाषित करना

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

 [Module(ModuleName = "ModuleA")] [ModuleDependency("ModuleD")] public class ModuleA: IModule { ... }

XAML में निर्भरता को परिभाषित करना

निम्नलिखित XAML शो कि मॉड्यूल एफ पर निर्भर करता है मॉड्यूल ई ।

 <Modularity:ModuleInfo Ref="ModuleF.xap" ModuleName="ModuleF" ModuleType="ModuleF.ModuleF, ModuleF, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" > <Modularity:ModuleInfo.DependsOn> <sys:String>ModuleE</sys:String> </Modularity:ModuleInfo.DependsOn> </Modularity:ModuleInfo>

एक विन्यास फाइल में निर्भरता को परिभाषित करना

निम्न उदाहरण फ़ाइल App.config पता चलता है कि मॉड्यूल डी निर्भर करता है मॉड्यूल बी ।

 <modules> <module assemblyFile="Modules/ModuleD.dll" moduleType="ModuleD.ModuleD, ModuleD" moduleName="ModuleD"> <dependencies> <dependency moduleName="ModuleB"/> </dependencies> </module>

मॉड्यूल की ऑन-डिमांड लोडिंग

मॉड्यूल को मांग पर लोड करने के लिए, आपको यह इंगित करना होगा कि उन्हें सेट किए InitializationModeगए विकल्प के साथ मॉड्यूल निर्देशिका में लोड किया जाना चाहिए OnDemand। उसके बाद, आपको अपने आवेदन में कोड को मॉड्यूल के लोड करने का अनुरोध करना चाहिए।

कोड में ऑन-डिमांड लोड नौकरी

यह निर्धारित करना कि एक मॉड्यूल को विशेषताओं के माध्यम से मांग पर लोड करना चाहिए, निम्न उदाहरण में दिखाया गया है।

 protected override void ConfigureModuleCatalog() { Type moduleCType = typeof(ModuleC); this.ModuleCatalog.AddModule(new ModuleInfo() { ModuleName = moduleCType.Name, ModuleType = moduleCType.AssemblyQualifiedName, InitializationMode = InitializationMode.OnDemand }); }

XAML में डिमांड डाउनलोड जॉब पर

InitializationMode.OnDemandजब आप XAML में मॉड्यूल निर्देशिका को परिभाषित करते हैं, तो आप यह निर्धारित कर सकते हैं कि निम्न कोड उदाहरण में दिखाया गया है।

 ... <Modularity:ModuleInfoGroup InitializationMode="OnDemand"> <Modularity:ModuleInfo Ref="ModuleE.xap" ModuleName="ModuleE" ModuleType="ModuleE.ModuleE, ModuleE, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" /> ...

कॉन्फ़िगरेशन फ़ाइल में ऑन-डिमांड लोड नौकरी

आप InitializationMode.OnDemandएक फ़ाइल में मॉड्यूल की निर्देशिका निर्दिष्ट करते समय निर्धारित कर सकते हैं App.config, जैसा कि निम्नलिखित कोड उदाहरण में दिखाया गया है।

 ... <module assemblyFile="Modules/ModuleC.dll" moduleType="ModuleC.ModuleC, ModuleC" moduleName="ModuleC" startupLoaded="false"/> ....

मॉड्यूल डाउनलोड अनुरोध

मॉड्यूल को मांग पर डाउनलोड करने के लिए निर्धारित होने के बाद, एप्लिकेशन अपने डाउनलोड का अनुरोध कर सकता है। कोड जो डाउनलोड शुरू करना चाहता IModuleManagerहै, उसे लोडर द्वारा कंटेनर में पंजीकृत सेवा के लिए एक लिंक प्राप्त करना होगा ।

 private void OnLoadModuleCClick(object sender, RoutedEventArgs e) { moduleManager.LoadModule("ModuleC"); }

पृष्ठभूमि में मॉड्यूल का रिमोट लोडिंग

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

रिमोट बूट के लिए एक मॉड्यूल तैयार करना

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

टिप्पणी
प्रत्येक .xap फ़ाइल के लिए, आपको एक नया Silverlight अनुप्रयोग प्रोजेक्ट बनाना होगा। विजुअल स्टूडियो 2008 और 2010 में, केवल एप्लिकेशन प्रोजेक्ट्स अलग-अलग .xapफ़ाइलों का उत्पादन करते हैं । आपको इन प्रोजेक्ट्स में जरूरत App.xamlया फाइलों की जरूरत नहीं होगी MainPage.xaml।

ट्रैकिंग डाउनलोड करें

वर्ग ModuleManagerलोडिंग मॉड्यूल की प्रगति को ट्रैक करने के लिए एक घटना प्रदान करता है। यह प्रगति का प्रतिशत प्राप्त करने के लिए अपलोड किए गए बाइट्स बनाम पूर्ण लोड आकार प्रदान करता है। आप इसका उपयोग दृश्य डाउनलोड प्रगति संकेतक प्रदर्शित करने के लिए कर सकते हैं।

 this.moduleManager.ModuleDownloadProgressChanged += this.ModuleManager_ModuleDownloadProgressChanged;

 void ModuleManager_ModuleDownloadProgressChanged(object sender, ModuleDownloadProgressChangedEventArgs e) { ... }

यह निर्धारित करते हुए कि एक मॉड्यूल लोड किया गया है

ModuleManagerमॉड्यूल लोड होने या लोड करने में असमर्थ होने पर सेवा ट्रैक करने के लिए एक घटना प्रदान करती है।

 this.moduleManager.LoadModuleCompleted += this.ModuleManager_LoadModuleCompleted;

 void ModuleManager_LoadModuleCompleted(object sender, LoadModuleCompletedEventArgs e) { ... }

एप्लिकेशन और मॉड्यूल को कम रखने के लिए, आपको एप्लिकेशन के साथ मॉड्यूल को एकीकृत करने के लिए इस घटना का उपयोग करने से बचना चाहिए। इसके बजाय मॉड्यूल विधि का उपयोग करें Initialize।

LoadModuleCompletedEventArgsसंपत्ति होती है IsErrorHandled। यदि मॉड्यूल लोड करने में विफल रहता है और एप्लिकेशन ModuleManagerत्रुटि को रिपोर्ट करने और अपवाद को फेंकने से रोकना चाहता है, तो आपको इस संपत्ति को सेट करना होगा true।

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

MEF में मॉड्यूल

यह खंड केवल MEF पर निर्भरता इंजेक्शन कंटेनर के रूप में उपयोग करते समय अंतर को उजागर करता है।

टिप्पणी
MEF का उपयोग करते समय, MefBootstrapperका उपयोग करता है MefModuleManager। यह ModuleManagerइंटरफ़ेस IPartImportsSatisfiedNotificationको विस्तारित करने और लागू करने के लिए सुनिश्चित करता है कि यह ModuleCatalogअपडेट किया जाता है जब नए प्रकार MEF द्वारा आयात किए जाते हैं।

MEF का उपयोग करके कोड में मॉड्यूल रजिस्टर करना

MEF का उपयोग करते समय, आप ModuleExportमॉड्यूल कक्षाओं में विशेषता को लागू कर सकते हैं ताकि MEF स्वचालित रूप से उनका पता लगा सके।

 [ModuleExport(typeof(ModuleB))] public class ModuleB : IModule { ... }

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

 protected override void ConfigureAggregateCatalog() { base.ConfigureAggregateCatalog(); // Module A        . this.AggregateCatalog.Catalogs.Add( new AssemblyCatalog(typeof(ModuleA).Assembly)); this.AggregateCatalog.Catalogs.Add( new AssemblyCatalog(typeof(ModuleC).Assembly)); }

प्रिज्म कार्यान्वयन MEF और प्रिज़्म को MefModuleManagerसिंक्रनाइज़ करता है , इस प्रकार प्रिज़्म को मॉड्यूल के माध्यम से या के साथ जोड़ा गया है ।AggregateCatalogModuleCatalogModuleCatalogAggregateCatalog

टिप्पणी
MEF का व्यापक उपयोग करता है Lazy, Value .
MEF का उपयोग कर एक स्थानीय निर्देशिका में मॉड्यूल की खोज

MEF एक वर्ग प्रदान करता है DirectoryCatalogजिसका उपयोग मॉड्यूल (और अन्य निर्यात किए गए MEF प्रकार) वाली असेंबली के लिए फ़ोल्डर को देखने के लिए किया जा सकता है। इस स्थिति में, आप ConfigureAggregateCatalogनिर्देशिका को पंजीकृत करने के लिए विधि को ओवरराइड करते हैं । यह दृष्टिकोण केवल WPF में उपलब्ध है।

इस दृष्टिकोण का उपयोग करने के लिए, आपको पहले मॉड्यूल नाम और उनकी निर्भरता को विशेषता का उपयोग करना होगा ModuleExport, जैसा कि निम्नलिखित उदाहरण में दिखाया गया है।
 protected override void ConfigureAggregateCatalog() { base.ConfigureAggregateCatalog(); DirectoryCatalog catalog = new DirectoryCatalog("DirectoryModules"); this.AggregateCatalog.Catalogs.Add(catalog); } 
MEF का उपयोग करके कोड में निर्भरता को परिभाषित करना

WPF अनुप्रयोगों के लिए, ModuleExportनीचे दिखाए गए अनुसार विशेषता का उपयोग करें।
 [ModuleExport(typeof(ModuleA), DependsOnModuleNames = new string[] { "ModuleD" })] public class ModuleA : IModule { ... } 
MEF , . MEF ModuleCatalog , , ModuleCatalog , XAML ( - ). ModuleCatalog MEF, ModuleCatalog , DependsOnModuleNames . MEF ModuleCatalog Silverlight, XAP.

MEF

MEF ModuleExport , , InitializationMode , , , .
 [ModuleExport(typeof(ModuleC), InitializationMode = InitializationMode.OnDemand)] public class ModuleC : IModule { ... } 
MEF

, Prism, MEF, MEF DeploymentCatalog , .xap .xap . MefXapModuleTypeLoader DeploymentCatalog AggregateCatalog .

.xap , . , , . Microsoft.Practices.Prism.MefExtensions.dll .

, DLL 'Copy Local'=false . .xap . .xap . , , , .xap , , .xap .

अतिरिक्त जानकारी

असेंबली कैशिंग के बारे में अधिक जानकारी के लिए, MSDN पर "कैसे करें: असेंबली लाइब्रेरी कैशिंग का उपयोग करें" देखें: http://msdn.microsoft.com/en-us/library/dd833069(VS.95).aspx

मॉड्यूलर के बारे में अधिक जानने के लिए प्रिज्म के सिद्धांत में, WPF क्विकस्टार्ट के लिए MEF के साथ मॉड्यूलरिटी देखें या WPF क्विकस्टार्ट के लिए एकता के साथ मॉड्यूलरिटी देखें। क्विकस्टार्ट्स के बारे में अधिक जानने के लिए, WPF के लिए मॉड्यूलर क्विकस्टार्ट्स देखें ।

प्रिज़्म लाइब्रेरी कार्यों के बारे में जानकारी के लिए मॉड्यूलर अनुप्रयोगों का निर्माण किया जाता है, " एक्सटेंड्स " को " एक्सटेंडिंग प्रिज्म " में देखें ।

प्रिज्म डेवलपर की गाइड - भाग 4, विकासशील मॉड्यूलर अनुप्रयोग