क्या OOP के फ्लेवर हैं जहां कुछ या सभी सॉलिड सिद्धांत स्वच्छ कोड के लिए एंटीथेटिकल हैं?


26

मैंने हाल ही में वीडियो गेम विकास में ओओपी के बारे में मेरे एक दोस्त के साथ चर्चा की थी।

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

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

यहां तक ​​कि SOLID सिद्धांतों पर विकिपीडिया प्रविष्टि में कहा गया है कि वे दिशानिर्देश हैं जो बनाए रखने योग्य कोड लिखने में मदद करते हैं और यह कि वे चुस्त और अनुकूली प्रोग्रामिंग की समग्र रणनीति का हिस्सा हैं।

तो, मेरा सवाल यह है:

क्या ओओपी में ऐसे मामले हैं जहां कुछ या सभी ठोस सिद्धांत खुद को साफ करने के लिए उधार नहीं देते हैं?

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

क्या अन्य हैं? शायद कुछ प्रकार के प्रोजेक्ट या कुछ निश्चित प्लेटफॉर्म कम SOLID दृष्टिकोण के साथ बेहतर काम करते हैं?

संपादित करें:

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

आप अपने प्रोजेक्ट के बारे में उत्सुक हैं, तो देखने के इस

2 संपादित करें:

मैंने सोचा कि इस प्रश्न का उत्तर 3 तरीकों में से एक में दिया जाएगा:

  1. हां, ओओपी डिजाइन सिद्धांत मौजूद हैं जो एसओएलआईडी के साथ आंशिक रूप से संघर्ष करते हैं
  2. हां, ओओपी डिजाइन सिद्धांत मौजूद हैं जो एसओएलआईडी के साथ पूरी तरह से संघर्ष करते हैं
  3. नहीं, SOLID मधुमक्खी का घुटना है और OOP इससे हमेशा बेहतर रहेगा। लेकिन, सब कुछ के साथ के रूप में, यह एक रामबाण नहीं है। पीकर होश में रहना।

विकल्प 1 और 2 की संभावना लंबे और दिलचस्प उत्तर उत्पन्न होंगे। विकल्प 3, दूसरी ओर, एक छोटा, अबाधित, लेकिन समग्र रूप से आश्वस्त, उत्तर होगा।

हम विकल्प 3 में परिवर्तित हो रहे हैं।


आप 'क्लीन कोड' को कैसे परिभाषित कर रहे हैं?
ग्रैंडमास्टरबी

इस प्रश्न के दायरे में क्लीन कोड, एक तरह से कोड संरचना है जो ओओपी के लक्ष्यों और चुने हुए डिजाइन सिद्धांतों के एक सेट को पूरा करता है। इसलिए, मैं OOP + SOLID द्वारा निर्धारित लक्ष्यों के संदर्भ में स्वच्छ कोड से परिचित हूं। मैं सोच रहा था कि वहाँ डिजाइन सिद्धांतों का एक और सेट है जो OOP के साथ काम करता है लेकिन SOLID के साथ पूरी तरह या आंशिक रूप से असंगत हैं।
मेटाफ़ाइट

1
मैं उस खेल के प्रदर्शन के बारे में कुछ और की तुलना में अधिक चिंतित हूं। जब तक हम टेक्स्ट-आधारित गेम के बारे में बात कर रहे हैं।
वृहस्पति

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

1
कुछ डाउनवोट के जोखिम पर, मैं "क्यों" सवाल पर वापस जाना चाहूंगा: खेल के विकास में ओओपी । खेल विकास की प्रकृति के कारण, "पारंपरिक" OOP इकाई / घटक प्रणाली, एक दिलचस्प संस्करण के विभिन्न जायके के पक्ष में प्रचलन से बाहर गिरने किया जा रहा है यहां उदाहरण के लिए। इसके बजाय मुझे लगता है कि सवाल "ठोस + ओओपी" नहीं होना चाहिए, बल्कि "ओओपी + गेम डेवलपमेंट" होना चाहिए। जब आप गेम देव के लिए ऑब्जेक्ट इंटरैक्शन का एक ग्राफ देखते हैं। बनाम एन-टियर एप्लिकेशन का कहना है, अंतर का मतलब हो सकता है कि एक नया प्रतिमान अच्छा है।
जे ट्राना

जवाबों:


20

क्या ओओपी में ऐसे मामले हैं जहां कुछ या सभी ठोस सिद्धांत खुद को साफ करने के लिए उधार नहीं देते हैं?

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

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

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


14
मुझे पसंद है लेकिन कभी-कभी अन्य चीजें अधिक अच्छी होती हैं । यह एक "पशु फार्म" यह करने के लिए लग रहा है। ;)
FrustratedWithFormsDesigner

12
+1 जब मैंने सिर्फ SOLID सिद्धांतों पर ध्यान दिया, तो मुझे 5 "सुंदर से सुंदर" दिखे। लेकिन उनमें से कोई भी शीर्ष सूखी, KISS, और "अपने इरादों को स्पष्ट कर दूं।" एसओएलआईडी का उपयोग करें, लेकिन थोड़ी सावधानी और संदेह दिखाएं।
user949300

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

एकीकरण अलगाव बनाम समुच्चय के कुशल डिजाइन के बारे में क्या? यदि मूल "अनुक्रम" इंटरफ़ेस [उदा। IEnumerable] जैसी विधियों Countऔर जैसे asImmutableगुणों को शामिल करता है और getAbilities[जिसकी वापसी इंगित करती है जैसे कि क्या चीजें Count"कुशल" होंगी], तो किसी के पास एक स्थिर विधि हो सकती है जो कई अनुक्रम लेती है और उन्हें एकत्र करती है ताकि वे 'एक लंबे समय तक अनुक्रम के रूप में व्यवहार करेंगे। यदि ऐसी क्षमताएं मूल अनुक्रम प्रकार में मौजूद हैं, भले ही वे केवल डिफ़ॉल्ट कार्यान्वयन के लिए श्रृंखला बनाते हैं, तो एक समुच्चय उन क्षमताओं को उजागर करने में सक्षम होगा ...
Supercat

... और बेस क्लास के साथ इस्तेमाल करने पर उन्हें कुशलता से लागू कर सकते हैं। यदि कोई दस-लाख की आइटम सूची एकत्र करता है, जो उसकी गिनती जानता है, और एक पाँच आइटम सूची जो केवल क्रमिक रूप से आइटम को पुनः प्राप्त कर सकती है, तो 10,000,003 वीं प्रविष्टि के लिए अनुरोध को पहली सूची से गिनती को पढ़ना चाहिए, और फिर दूसरी से तीन आइटमों को पढ़ना चाहिए। । रसोई-सिंक इंटरफेस आईएसपी का उल्लंघन कर सकते हैं, लेकिन वे उन्हें कुछ रचना / एकत्रीकरण परिदृश्यों के प्रदर्शन में सुधार कर सकते हैं।
सुपरकैट

13

मुझे लगता है कि मेरे पास एक असामान्य दृष्टिकोण है कि मैंने वित्त और खेल दोनों में काम किया है।

खेलों में मुझे जो भी प्रोग्रामर मिले, उनमें से कई सॉफ्टवेयर इंजीनियरिंग में भयानक थे - लेकिन उन्हें SOLID जैसी प्रथाओं की कोई आवश्यकता नहीं थी। परंपरागत रूप से, वे अपने खेल को एक बॉक्स में रखते हैं - फिर वे कर रहे हैं।

वित्त में, मैंने पाया है कि डेवलपर्स वास्तव में सुस्त और अनुशासनहीन हो सकते हैं क्योंकि उन्हें उस प्रदर्शन की आवश्यकता नहीं है जो आप खेलों में करते हैं।

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

यह कहना नहीं है कि SOLID आलोचना के बिना नहीं है। उन्हें सिद्धांत कहा जाता है और फिर भी उन्हें दिशा-निर्देशों की तरह पालन किया जाना चाहिए? तो वास्तव में मुझे उनका पालन कब करना चाहिए? मुझे नियम कब तोड़ने चाहिए?

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

यह कहना गैर-अनुक्रमिक है कि, "बड़ी संख्या में कक्षाएं एक रखरखाव दुःस्वप्न का कारण बन सकती हैं"। हालांकि, यदि एसआरपी की सही ढंग से व्याख्या नहीं की गई है तो आप इस समस्या को आसानी से समाप्त कर सकते हैं।

मैं बहुत ज्यादा कोई जिम्मेदारी की कई परतों के साथ कोड देखा है। एक राज्य से दूसरे वर्ग के अलावा कुछ नहीं करने वाली कक्षाएं। अप्रत्यक्ष की कई परतों की क्लासिक समस्या।

यदि आपके कोड में सामंजस्य की कमी है तो SRP समाप्त हो सकता है। जब आप किसी सुविधा को जोड़ने का प्रयास करते हैं तो आप यह बता सकते हैं। यदि आपको हमेशा एक ही समय में कई जगह बदलना पड़ता है तो आपके कोड में सामंजस्य का अभाव होता है।

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

एलएसपी के बारे में आपका तर्क काल्पनिक लगता है और मुझे वास्तव में समझ में नहीं आता कि सुरक्षित विरासत के दूसरे रूप से आपका क्या मतलब है?

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

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

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


1
यदि आपके पास बड़ी संख्या में निर्माता पैरामीटर हैं, तो यह बताता है कि आपने SRP का उल्लंघन किया है। फिर भी एक डीआई कंटेनर बड़ी संख्या में निर्माण मापदंडों से जुड़े दर्द को दूर करता है, इसलिए मैं डीआईपी पर आपके बयानों से असहमत हूं।
स्टीफन

ये सभी 'सिद्धांत' वास्तव में सिद्धांत लेकिन दिशा-निर्देश देते हैं। वे एक संतुलन कार्य कर रहे हैं; जैसा कि मैंने अपने पोस्ट में कहा था कि एसआरपी भी अत्यधिक समस्याग्रस्त हो सकती है।
डेव हिलेरी सेप

अच्छा उत्तर, +1। एक बात जो मैं जोड़ना चाहूंगा: मैंने स्कीट की समीक्षा को OCP के मानक पाठ्यपुस्तकों की परिभाषा के अधिक आलोचकों को पढ़ा, न कि OCP के पीछे के मुख्य विचारों को। मेरी समझ में, संरक्षित भिन्नता विचार वह है जो ओसीपी को पहली जगह से होना चाहिए था।
डॉक ब्राउन

5

यहाँ मेरी राय है:

यद्यपि SOLID सिद्धांत एक गैर-निरर्थक और लचीले कोडबेस के लिए लक्ष्य रखते हैं, यह पठनीयता और रखरखाव में एक व्यापार बंद हो सकता है यदि बहुत अधिक कक्षाएं और परतें हैं।

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

मुझे लगता है कि ठोस सिद्धांत ओओपी से असहमत नहीं हैं, लेकिन फिर भी इनका पालन करते हुए गैर-स्वच्छ कोड लिखना संभव है।


3
+1 लगभग परिभाषा के अनुसार, एक अत्यधिक लचीली प्रणाली को कम लचीला होना चाहिए जो कि कम लचीला है। जोड़ा गया जटिलता के कारण लचीलापन एक लागत पर आता है।
एंडी

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

3

अपने शुरुआती विकासशील दिनों में, मैंने C ++ में एक Roguelike लिखना शुरू किया। जैसा कि मैं अपनी शिक्षा से सीखी गई अच्छी वस्तु-उन्मुख पद्धति को लागू करना चाहता था, मैंने तुरंत खेल आइटमों को C ++ ऑब्जेक्ट्स के रूप में देखा। Potion, Swords, Food, Axe, Javelinsआदि सब एक बुनियादी कोर से प्राप्त Itemकोड, नाम, आइकन, वजन, सामान उस तरह से निपटने।

फिर, मैंने बैग तर्क को कोडित किया, और एक समस्या का सामना किया। मैं Itemsबैग में रख सकता हूं , लेकिन फिर, अगर मैं एक उठाता हूं, तो मुझे कैसे पता चलेगा कि यह एक Potionया एक है Sword? मैंने इंटरनेट पर देखा कि आइटम को कैसे डाउन किया जाए। मैंने रनटाइम जानकारी को सक्षम करने के लिए संकलक विकल्पों को हैक किया ताकि मुझे पता चल सके कि मेरे अमूर्त Itemसही प्रकार क्या हैं, और यह जानने के लिए कि मैं कौन से संचालन की अनुमति दूंगा (उदाहरण के लिए पीने से बचें Swordsऔर Potionsअपने पैरों पर रखें)

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

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


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

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

1
@ यूफोरिक मैंने बहुत कोशिश की। मेरे पास वस्तु-उन्मुख पद्धति थी। कार्यप्रणाली होने और इसे सफलतापूर्वक लागू करने के बीच एक अंतर है, हालाँकि :)
आर्थर हैवेलिस

2
यह ओओडी में स्वच्छ कोड के विपरीत चलने वाले SOLID सिद्धांतों का एक उदाहरण कैसे है? यह एक गलत डिजाइन के उदाहरण की तरह लगता है - यह ओओपी के लिए रूढ़िवादी है!
एंड्रेस एफ।

1
आपके आधार ITEM वर्ग में FALSE के लिए डिफ़ॉल्ट रूप से "कैनएक्सएक्सएक्सएक्स" बूलियन विधियों की संख्या होनी चाहिए। फिर आप अपने Javelin वर्ग में सही लौटने के लिए "canThrow ()" और अपने Postion वर्ग के लिए सही लौटने के लिए canEat () सेट कर सकते हैं।
जेम्स एंडरसन

3

उनकी चिंता यह थी कि बड़ी संख्या में कक्षाएं एक रखरखाव दुःस्वप्न में बदल जाएंगी। मेरा विचार था कि इसका सटीक विपरीत प्रभाव होगा।

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

लेकिन मेरे लिए समस्या यह है कि मैं कम से कम एक ठोस-अनुरूप वास्तुकला (इसे COM- आधारित था) के रूप में कुछ हद तक कहा जा सकता है के साथ संघर्ष किया, गंभीर रूप से "बहुत सारे वर्गों" या "बहुत अधिक कार्यों" के रूप में उबला हो सकता है आपका मित्र वर्णन कर सकता है। मैं विशेष रूप से कहूंगा, "बहुत सारे इंटरैक्शन, बहुत सी जगहें जो संभवतः दुर्व्यवहार कर सकती हैं, बहुत सी जगहें जो संभवतः दुष्प्रभाव पैदा कर सकती हैं, बहुत सी जगहें जिन्हें बदलने की आवश्यकता हो सकती है, और बहुत से स्थान जो हम सोचते हैं कि वे नहीं कर सकते हैं। । "

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

यहाँ छवि विवरण दर्ज करें

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

इसलिए वैकल्पिक रूप से मैंने गेमिंग उद्योग में आमतौर पर उपयोग की जाने वाली इकाई-घटक प्रणाली वास्तुकला की खोज शुरू की। इस तरह से सब कुछ बदल गया:

यहाँ छवि विवरण दर्ज करें

और वाह! स्थिरता के संदर्भ में ऐसा अंतर था। निर्भरता अब अमूर्तता की ओर नहीं बढ़ी बल्कि डेटा (घटकों) की । और मेरे मामले में कम से कम, डेटा बहुत अधिक स्थिर था और बदलती आवश्यकताओं के बावजूद डिजाइन के संदर्भ में सही होने के लिए आसान है (हालांकि हम एक ही डेटा के साथ क्या कर सकते हैं लगातार बदलती आवश्यकताओं के साथ बदल रहा है)।

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

ईसीएस दृष्टिकोण के तहत बदलती आवश्यकताओं के साथ, अक्सर उस डेटा पर काम करने वाले एक या दो सिस्टम को बदलने या केवल एक नई प्रणाली को पेश करने की आवश्यकता होती है, या नए डेटा की आवश्यकता होने पर एक नए घटक को प्रस्तुत करना होता है।

इसलिए मेरे डोमेन के लिए कम से कम, और मैं लगभग निश्चित हूं कि यह हर किसी के लिए नहीं है, इसने चीजों को इतना आसान बना दिया क्योंकि निर्भरता स्थिरता की ओर बह रही थी (ऐसी चीजें जिन्हें अक्सर बदलने की आवश्यकता नहीं थी)। COM वास्तुकला में ऐसा नहीं था जब निर्भरता समान रूप से अमूर्तता की ओर बह रही थी। मेरे मामले में यह पता लगाना बहुत आसान है कि मोशन अपफ्रंट के लिए कौन सा डेटा आवश्यक है बजाय इसके कि आप इसके साथ क्या कर सकते हैं, जो अक्सर नई आवश्यकताओं के आते ही महीनों या वर्षों में बदल जाता है।

यहाँ छवि विवरण दर्ज करें

क्या ओओपी में ऐसे मामले हैं जहां कुछ या सभी ठोस सिद्धांत खुद को साफ करने के लिए उधार नहीं देते हैं?

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

यह जरूरी नहीं है कि निर्भरता अमूर्तता की ओर प्रवाहित होनी चाहिए क्योंकि डीआईपी सुझाव देगा; निर्भरता उन चीजों की ओर प्रवाहित होनी चाहिए जो भविष्य में बदलाव की आवश्यकता की संभावना नहीं है। यह सभी मामलों में सार हो सकता है या नहीं (यह निश्चित रूप से मेरा नहीं था)।

  1. हां, ओओपी डिजाइन सिद्धांत मौजूद हैं जो एसओएलआईडी के साथ आंशिक रूप से संघर्ष करते हैं
  2. हां, ओओपी डिजाइन सिद्धांत मौजूद हैं जो एसओएलआईडी के साथ पूरी तरह से संघर्ष करते हैं।

मुझे यकीन नहीं है कि ईसीएस वास्तव में ओओपी का स्वाद है। कुछ लोग इसे इस तरह से परिभाषित करते हैं, लेकिन मैं इसे युग्मन विशेषताओं और कार्यक्षमता (सिस्टम) से डेटा (घटकों) के पृथक्करण और डेटा एनकैप्सुलेशन की कमी के साथ स्वाभाविक रूप से अलग देखता हूं। अगर इसे OOP का एक रूप माना जाए, तो मुझे लगता है कि यह SOLID (कम से कम SRP के सख्त विचारों, खुले / बंद, liskov प्रतिस्थापन, और DIP) के साथ संघर्ष में बहुत अधिक है। लेकिन मुझे उम्मीद है कि यह एक मामले और डोमेन का एक उचित उदाहरण है जहां एसओएलआईडी के सबसे बुनियादी पहलू हैं, कम से कम क्योंकि लोग आमतौर पर उन्हें एक अधिक पहचानने योग्य ओओपी संदर्भ में व्याख्या करेंगे, इसलिए लागू नहीं हो सकता है।

नन्हा वर्ग

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

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

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

सहभागिता

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

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

यह इस तरह से कुछ मोड़ सकता है (जहां आरेख में सब कुछ कार्यक्षमता है, और जाहिर है कि एक वास्तविक दुनिया का परिदृश्य कई, कई बार वस्तुओं की संख्या होगा, और यह "इंटरैक्शन" आरेख है, न कि एक युग्मन, एक युग्मन के रूप में। एक के बीच में सार होगा):

यहाँ छवि विवरण दर्ज करें

... इसके लिए जहां केवल सिस्टम में कार्यक्षमता है (नीले घटक अब केवल डेटा हैं, और अब यह एक युग्मन आरेख है):

यहाँ छवि विवरण दर्ज करें

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


मुझे बातचीत और युग्मन के बीच का अंतर पसंद है। यद्यपि आपका पहला इंटरैक्शन आरेख बाधित है। यह एक प्लैनर ग्राफ है, इसलिए तीर को पार करने की कोई आवश्यकता नहीं है।
D ड्रमर

2

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

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


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

1
चुंबन और YAGNI हमेशा प्राथमिकता ले लिया, तो आप अभी भी 1 है और 0 के दशक में कोडिंग किया जाना चाहिए। असेंबलर सिर्फ कुछ और हैं जो गलत हो सकते हैं। कोई चुंबन और बाहर डिजाइन का काम के कई लागत के दो YAGNI बिंदु। यह लागत हमेशा किसी भी डिजाइन के काम के लाभ के खिलाफ संतुलित होनी चाहिए। SOLID के लाभ हैं जो कुछ मामलों में लागतों के लिए बनाते हैं। यह बताने का कोई सरल तरीका नहीं है कि आपने लाइन कब पार की है।
कैंडिड_ओरेंज

@ कंडिडऑरेन्ज: मैं असहमत हूं कि उच्च-स्तरीय भाषा में कोड की तुलना में मशीन कोड सरल है। , अमूर्त की कमी के कारण आकस्मिक जटिलता का एक बहुत युक्त तो यह निश्चित रूप से मशीन कोड में एक ठेठ आवेदन लिखने के लिए तय करने के लिए चुंबन नहीं है अप मशीन कोड समाप्त हो जाती है।
जैक्सबी

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

1
@JacquesB - सच। और OCP YAGNI के लिए अपने मूल स्थान पर है; हालाँकि आप इसे प्राप्त करने के बारे में जाते हैं, बाद में सुधार को सक्षम करने के लिए आपको विस्तार बिंदुओं में डिज़ाइन करने की आवश्यकता होती है। दो आदर्शों के बीच एक उपयुक्त संतुलन बिंदु खोजना मुश्किल है।
जूल्स

1

मेरे अनुभव में:-

बड़ी कक्षाओं को बनाए रखना अधिक कठिन होता है क्योंकि वे बड़े होते हैं।

छोटी कक्षाओं को बनाए रखना आसान होता है और छोटी कक्षाओं के संग्रह को बनाए रखने की कठिनाई अंकगणितीय रूप से कक्षाओं की संख्या में बढ़ जाती है।

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


0

मुझे हमेशा ठोस के 'एस' के बीच की रेखा खींचना कठिन लगता है और (पुराने जमाने का हो सकता है) किसी वस्तु को स्वयं का सारा ज्ञान होने देना चाहिए।

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

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

और हाँ मुझे पता है कि आप अपनी वस्तुओं को डेटाबेस में बाँधना नहीं चाहते हैं लेकिन आप इसे हल करने के लिए बड़े बंधक वर्ग में एक भंडार का इंजेक्शन लगा सकते हैं।

इसके अलावा, कक्षाओं के लिए अच्छे नाम ढूंढना हमेशा आसान नहीं होता है जो केवल एक छोटी सी बात करते हैं।

इसलिए मुझे इस बात पर यकीन नहीं है कि 'एस' हमेशा एक अच्छा विचार है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.