मैं काफी व्यावहारिक हूँ, लेकिन यहाँ मेरी मुख्य चिंता यह है कि आप इसे ConfigBlockअपने इंटरफ़ेस डिज़ाइन को संभवतः खराब तरीके से हावी होने दे सकते हैं । जब आपके पास ऐसा कुछ हो:
explicit MyGreatClass(const ConfigBlock& config);
... एक अधिक उपयुक्त इंटरफ़ेस इस तरह हो सकता है:
MyGreatClass(int foo, float bar, const string& baz);
... के रूप में सिर्फ चेरी के लिए इन foo/bar/bazक्षेत्रों में एक बड़े पैमाने पर लेने का विरोध किया ConfigBlock।
आलसी इंटरफ़ेस डिजाइन
प्लस साइड पर, इस तरह का डिज़ाइन आपके कंस्ट्रक्टर के लिए एक स्थिर इंटरफ़ेस डिज़ाइन करना आसान बनाता है, उदाहरण के लिए, यदि आप कुछ नया करना चाहते हैं, तो आप बस इसे लोड कर सकते हैं ConfigBlock(संभवतः बिना किसी कोड परिवर्तन के) और फिर चेरी- किसी भी प्रकार के इंटरफ़ेस परिवर्तन के बिना आपको जो भी नया सामान चाहिए, उसे लागू करें MyGreatClass।
तो यह एक समर्थक और चोर की तरह है कि यह आपको और अधिक सावधानी से सोचा जाने वाला इंटरफ़ेस डिजाइन करने से मुक्त करता है जो केवल उन इनपुट को स्वीकार करता है जो वास्तव में इसकी आवश्यकता है। यह इस बात पर लागू होता है कि, "बस मुझे डेटा का इतना बड़ा हिस्सा दे दो, मुझे इससे जो चाहिए, वह निकाल दूंगा" जैसा कि कुछ और के विपरीत है, "ये सटीक पैरामीटर हैं जो इस इंटरफ़ेस को काम करने की आवश्यकता है।"
इसलिए निश्चित रूप से कुछ पेशेवरों के यहाँ हैं, लेकिन वे विपक्ष द्वारा भारी पड़ सकते हैं।
युग्मन
इस परिदृश्य में, ऐसे सभी वर्गों को एक ConfigBlockउदाहरण से निर्मित किया जा रहा है, जिनकी निर्भरता इस प्रकार है:
यह PITA बन सकता है, उदाहरण के लिए, यदि आप Class2अलगाव में इस आरेख में इकाई परीक्षण करना चाहते हैं । आपको सतही रूप से विभिन्न ConfigBlockइनपुट्स का अनुकरण करना पड़ सकता है, जिसमें संबंधित क्षेत्रों Class2में विभिन्न स्थितियों के तहत इसका परीक्षण करने में सक्षम होने के लिए संबंधित क्षेत्रों में रुचि है।
किसी भी तरह के नए संदर्भ में (चाहे इकाई परीक्षण या पूरी नई परियोजना), किसी भी तरह की कक्षाएं (पुनः) उपयोग के बोझ को और अधिक बढ़ा सकती हैं, जैसा कि हम अंत ConfigBlockमें सवारी के लिए हमेशा साथ लाते हैं , और इसे स्थापित करते हैं। तदनुसार।
पुनर्प्रयोग / Deployability / Testability
इसके बजाय यदि आप इन इंटरफेस को उचित रूप से डिज़ाइन करते हैं, तो हम उन्हें ConfigBlockइस तरह से समाप्त कर सकते हैं और कुछ इस तरह से समाप्त कर सकते हैं :
यदि आप इस उपरोक्त आरेख में देखें, तो सभी वर्ग स्वतंत्र हो जाते हैं (उनके अभिवाही / बाहर जाने वाले युग्मन 1 से कम हो जाते हैं)।
यह बहुत अधिक स्वतंत्र वर्गों (कम से कम स्वतंत्र ConfigBlock) की ओर जाता है जो नए परिदृश्यों / परियोजनाओं में उपयोग (परीक्षण) / परीक्षण के लिए बहुत आसान हो सकता है।
अब यह Clientकोड समाप्त हो रहा है जो कि सब कुछ पर निर्भर है और इसे सभी को एक साथ इकट्ठा करना है। बोझ को समाप्त होता है इस ग्राहक कोड को हस्तांतरित किया जा रहा है ताकि उपयुक्त फ़ील्ड्स को पढ़ने के लिए ConfigBlockऔर उन्हें मापदंडों के रूप में उपयुक्त कक्षाओं में पास किया जा सके। फिर भी इस तरह के ग्राहक कोड आमतौर पर एक विशिष्ट संदर्भ के लिए संकीर्ण रूप से डिज़ाइन किए जाते हैं, और पुन: उपयोग के लिए इसकी क्षमता आम तौर पर वैसे भी ज़िल्च या बंद होने वाली है (यह आपके आवेदन का mainप्रवेश बिंदु फ़ंक्शन या ऐसा कुछ हो सकता है)।
तो पुन: प्रयोज्य और परीक्षण के दृष्टिकोण से, इन वर्गों को अधिक स्वतंत्र बनाने में मदद मिल सकती है। अपनी कक्षाओं का उपयोग करने वालों के लिए एक इंटरफेस के दृष्टिकोण से, यह स्पष्ट रूप से यह बताने में मदद कर सकता है कि उन्हें केवल एक बड़े पैमाने के बजाय किन मापदंडों की आवश्यकता है ConfigBlockजो डेटा फ़ील्ड के पूरे ब्रह्मांड को हर चीज के लिए आवश्यक मॉडल बनाते हैं।
निष्कर्ष
सामान्य तौर पर, इस तरह की क्लास-ओरिएंटेड डिज़ाइन जो एक मोनोलिथ पर निर्भर करती है जिसके पास इस तरह की विशेषताओं के लिए आवश्यक हर चीज होती है। परिणाम के रूप में उनकी प्रयोज्यता, तैनाती, पुन: प्रयोज्यता, परीक्षणशीलता आदि में काफी गिरावट आ सकती है। फिर भी वे इंटरफ़ेस डिज़ाइन को सरल बना सकते हैं यदि हम उस पर सकारात्मक स्पिन का प्रयास करते हैं। यह उन पेशेवरों और विपक्षों को मापने और यह तय करने के लिए है कि व्यापार-मूल्य इसके लायक हैं या नहीं। आम तौर पर इस तरह के डिजाइन के खिलाफ गलती करना ज्यादा सुरक्षित होता है जहां आप कक्षाओं में एक मोनोलिथ से चेरी-पिकिंग करते हैं जो आम तौर पर एक अधिक सामान्य और व्यापक रूप से लागू होने वाले डिजाइन को बनाने के लिए होता है।
अंतिम पर कम नहीं:
extern CodingBlock MyCodingBlock;
... यह निर्भरता इंजेक्शन दृष्टिकोण की तुलना में ऊपर वर्णित विशेषताओं के संदर्भ में संभावित रूप से भी बदतर (अधिक तिरछी?) है, क्योंकि यह न केवल आपकी कक्षाओं को युग्मित करता है ConfigBlocks, बल्कि सीधे इसके एक विशिष्ट उदाहरण के लिए भी समाप्त होता है। यह आगे चलकर प्रयोज्यता / तैनाती / परीक्षणशीलता को कम करता है।
मेरी सामान्य सलाह यह है कि आप अपने मापदंडों को प्रदान करने के लिए इन प्रकार के मोनोलिथ पर निर्भर न हों, कम से कम सबसे आम तौर पर लागू होने वाली कक्षाओं के लिए, जो आपके द्वारा डिज़ाइन किए गए हैं, के आधार पर गलतियाँ करना। और निर्भरता इंजेक्शन के बिना वैश्विक दृष्टिकोण से बचें यदि आप तब तक नहीं कर सकते जब तक कि आपके पास वास्तव में एक बहुत मजबूत और आश्वस्त कारण न हो।