मैं अपने (ज्यादातर कनिष्ठ) सहयोगियों पर निर्भरता व्युत्क्रम सिद्धांत की व्याख्या करने की कोशिश कर रहा हूं। हम कैसे परिभाषित कर सकते हैं कि कौन सी "उच्च-स्तरीय नीति" है और कौन सा एक सॉफ़्टवेयर में "निम्न-स्तरीय विवरण" है? उदाहरण के लिए, यदि हमारा सॉफ़्टवेयर कई व्यावसायिक अनुप्रयोगों के वर्कफ़्लो को स्वचालित करता है, तो हम क्यों कहते हैं कि वर्कफ़्लो स्वचालन उच्च-स्तरीय नीति है और व्यावसायिक अनुप्रयोग विवरण हैं?
निर्भरता व्युत्क्रमण सिद्धांत: अन्य लोगों के लिए "उच्च-स्तरीय नीति" और "निम्न-स्तरीय विवरण" कैसे परिभाषित करें?
जवाबों:
नोट: यह मेरे पहले के उदाहरण से पूरी तरह से फिर से लिखा गया है
पावर सॉकेट के बारे में सोचो। किसी भी राष्ट्र में, उच्च-स्तरीय नीति यह है कि पावर सॉकेट हमेशा समान होते हैं। इससे कोई फर्क नहीं पड़ता कि आपको बिजली (कोयला, गैस, परमाणु) से बिजली कहाँ मिलती है, दीवार पर सॉकेट हमेशा कनेक्टर्स के समान सेट के माध्यम से बिजली की समान मात्रा को बाहर करना चाहिए।
अब आप किसी भी डिवाइस को उस सॉकेट में प्लग कर सकते हैं, क्योंकि उन सभी में एक कॉमन इंटरफेस है, "प्लग"। उच्च-स्तरीय नीति को कभी भी उस कार्यान्वयन विवरण के किसी भाग को निर्धारित नहीं करना पड़ता है। बस कुछ में प्लग और यह चला जाता है।
अब अगर आपके पास एक ऐसा उपकरण है जो एसी बिजली नहीं चाहता है - तो यह 7V डीसी सर्किट पर चलता है - आप अभी भी उस उच्च-स्तरीय नीति का उपयोग कर सकते हैं, आपको बस बिजली की आपूर्ति और डिवाइस के बीच किसी प्रकार के एडाप्टर की आवश्यकता है। और, क्योंकि सभी की समान उच्च-स्तरीय नीति है, निर्माता उच्च-स्तरीय नीति में कोई बदलाव किए बिना, कार्यान्वयन में निर्माण कर सकता है। कार्यान्वयन को नीति से जोड़ने वाला व्यक्ति (आप, अपना लैपटॉप प्लग इन करना) वास्तव में या तो समझने की आवश्यकता नहीं है।
इसके अलावा, यदि निर्माता उसी डिवाइस को किसी अन्य देश में बेचना चाहता है, तो उन्हें केवल एक अलग एडेप्टर विकसित करना होगा। तो एक ही कार्यान्वयन कई नीतियों के साथ काम कर सकता है जबकि एक ही नीति कई कार्यान्वयन चला सकती है।
यह निर्भरता उलटा का एक आदर्श उदाहरण है।
लेकिन यहाँ दिलचस्प सा है: जो मैंने पहले कहा था, उस पर वापस जाएं। "इससे कोई फर्क नहीं पड़ता कि आपको बिजली कहाँ से मिलती है।" यह एक कार्यान्वयन विवरण भी है। उच्च-स्तरीय नीति अभी भी है कि सभी पावर सॉकेट एक ही आकार के हैं और एक ही प्रकार की शक्ति का उत्सर्जन करते हैं। निम्न-स्तरीय कार्यान्वयन विवरण दोनों हैं जहां बिजली आती है और यह क्या चलता है।
प्रोग्रामिंग के संदर्भ में, इसका मतलब है कि उच्च-स्तरीय नीति इंटरफ़ेस है (जहां कोई भाषा इसका समर्थन करती है। DI का एक अन्य रूप बतख-टाइपिंग है।) जो एक एपीआई प्रदान करता है और आवेदन की खपत करता है, और निम्न-स्तरीय कार्यान्वयन विवरण दोनों हैं। एप्लिकेशन इसे और API का उपभोग करता है, जिनमें से किसी को भी एक दूसरे को समझने की आवश्यकता नहीं है।
एक ही कार्यान्वयन को विभिन्न नीतियों में फिट करने के लिए एडेप्टर का उपयोग किया जा सकता है।
+1 क्रि। मुझे नहीं पता था कि मैं एक साधारण पावर सॉकेट से इतना कुछ सीख सकता हूं :)
—
dreza
सॉफ़्टवेयर पुन: उपयोग में क्लासिक दृष्टिकोण उन घटकों का निर्माण करना है जो कुछ और पर निर्भर नहीं करते हैं (जो कि उन्हें निम्न-स्तरीय बनाता है), और फिर उच्च-स्तरीय घटकों का निर्माण करते हैं जो निचले-स्तर के घटकों पर निर्भर करते हैं। "उच्च स्तर" और "निम्न स्तर" निर्भरता की दिशा द्वारा विशिष्ट रूप से निर्धारित किए जाते हैं, जो घटक के कार्य के लिए अंतर्निहित नहीं है, लेकिन अक्सर सिर्फ एक वास्तुशिल्प निर्णय होता है।
इसलिए, जब एकल व्यावसायिक अनुप्रयोग वर्कफ़्लो स्वचालन के लिए कोई निर्भरता के साथ निर्मित होते हैं, लेकिन आपके कार्य-प्रवाह नियंत्रक का व्यवसाय अनुप्रयोग के लिए प्रत्यक्ष निर्भरता है, तो यह स्पष्ट होना चाहिए कि वर्कफ़्लो स्वचालन "उच्च स्तर की नीति" है और व्यावसायिक अनुप्रयोग एक है "निम्न स्तर" घटक। ध्यान दें कि यह संरचना अनिवार्य नहीं है - यदि आपका वर्कफ़्लो ऑटोमेशन घटक एक सामान्य ढांचा है, जो या तो आपके विशिष्ट व्यवसाय अनुप्रयोगों के लिए युग्मित नहीं है, लेकिन विभिन्न अनुप्रयोगों की सेवा के लिए कॉन्फ़िगर किया जा सकता है, तो आपने पहले ही डीआईपी लागू करना शुरू कर दिया है। इस स्थिति में, "उच्च स्तर" / "निम्न स्तर" पृथक्करण उन दो चीजों के बीच किसी भी अधिक अर्थ नहीं कर सकता है।
तो, नाम "निर्भरता उलटा" कुछ भ्रामक है - चूंकि निर्भरता "उलट" नहीं हैं, लेकिन पूरी तरह से हटा दिया गया है (या अधिक सटीक: मधुमक्खी पालन समय निर्भरता से रन टाइम निर्भरता में परिवर्तित)।
काफी नहीं। उलटा इसलिए होता है क्योंकि निचले स्तर इंटरफ़ेस पर निर्भरता लेते हैं। इंटरफ़ेस अलगाव सिद्धांत (SOLID में I) को लागू करते हुए, वह इंटरफ़ेस क्लाइंट के लिए "संबंधित" है। तो निम्न स्तर का रूपक ग्राहक पर निर्भरता लेता है।
—
माइकल ब्राउन
@ माइकबर्न: यह एक संभावित दृष्टिकोण है। मैं उस दृष्टिकोण को पसंद करता हूं जहां इंटरफ़ेस ए या बी से संबंधित नहीं है, लेकिन ए और बी के बुनियादी ढांचे या पर्यावरण के लिए
—
डॉक्टर ब्राउन 16
मैं एक सरल छवि का उपयोग डीआईपी को समझाने के लिए करता हूं। सॉफ्टवेयर विकास का क्लासिक दृश्य एक निर्माण प्रक्रिया के रूप में है, जिसमें निचले स्तर के शीर्ष पर बैठी प्रत्येक परत है जो इसका समर्थन करती है। डिपेंडेंसी इनवर्जन सिद्धांत का उपयोग करना मोबाइल बनाने की तरह है।
निचली परतों पर बैठे उच्च परतों के बजाय, मोबाइल इंटरफ़ेस में उच्च परतें स्ट्रिंग के माध्यम से निचली परतों के साथ होती हैं जो उन्हें जोड़ती हैं। एक तरह से, निचली परतें समर्थन के लिए उस इंटरफ़ेस पर निर्भर करती हैं (स्ट्रिंग के बिना वे गिर जाते थे)। यह संक्षेप में डीआईपी है।
अच्छी तुलना के लिए +1। इस तस्वीर में, आप मेरी बात देख सकते हैं - सभी परतें इंटरफेस पर निर्भर करती हैं, लेकिन उच्चतर स्तर पर निचली परतें या इसके विपरीत नहीं।
—
डॉक ब्राउन
मैं देख रहा हूं कि आप क्या कह रहे हैं, इंटरफ़ेस न तो उच्च या निम्न स्तर का है।
—
माइकल ब्राउन
उन्होंने यह नहीं पूछा कि डीआईपी की व्याख्या कैसे करें, उन्होंने पूछा कि कैसे समझाया जाए कि आवेदन के कौन से हिस्से उच्च-स्तरीय नीति हैं और जो निम्न-स्तर के कार्यान्वयन हैं। आपके सादृश्य को ऐसा करने के लिए दूर तक विस्तार नहीं करना पड़ता है। आपको बस स्ट्रिंग को बदलने के बिना सजावट को बदलने में सक्षम होने की आवश्यकता है (यदि आप तब उच्च-स्तरीय मोबाइल नीति सजावट के कार्यान्वयन के बारे में बहुत अधिक विवरण नहीं कर सकते हैं)।
—
पृ।
(और, वास्तव में, आप विभिन्न सामग्रियों से पूरी तरह से नया मोबाइल बना सकते हैं और उसी सजावट को बंद कर सकते हैं - जो कि डॉक ब्राउन का बिंदु है)
—
पीडीआर