आपको जेनेरिक प्रकारों को कब समाहित करना चाहिए?

Question

मैं लोगों के एक नंबर देखा है सुझाव है कि आप अपने डोमेन के करीब एक वर्ग के साथ सामान्य प्रकार संपुटित चाहिए, उदाहरण के स्टीव और नेट के लिए Growing Object-Oriented Software, Guided by Tests में सुझाव है कि:

अंगूठे का हमारा नियम है कि हम करने की कोशिश जेनरिक के साथ प्रकारों के चारों ओर गुजरने की सीमा [...]। विशेष रूप से संग्रह पर लागू होने पर, हम इसे डुप्लिकेशन के रूप में देखते हैं। यह एक संकेत है कि एक डोमेन अवधारणा है जिसे एक प्रकार में निकाला जाना चाहिए।

आम तौर पर जब यह एक अच्छा विचार कुछ इस तरह करना है ..

class PersonList : List<Person> 

.. बजाय सीधे List<Person> का उपयोग कर?

Answer 1

क्योंकि टाइप पैरामीटर छोड़ना वास्तव में DRY नहीं है। इस वर्ग पर विचार करें:

class Muffin { 
    List<string> _peopleWhoLikeMuffins = new List<string>(); 

    public Muffin(List<string> peopleWhoLikeMuffins) { 
     _peopleWhoLikeMuffins = peopleWhoLikeMuffins); 
    } 

    public void AddMuffinLiker(string p) { 
     _peopleWhoLikeMuffins.Add(p); 
    } 
} 

यह वास्तव में कम है और केवल बुनियादी कार्यक्षमता शामिल हैं, लेकिन मैं string का इस्तेमाल किया था - genertic प्रकार पैरामीटर - चार बार। और यह हमेशा वही होगा। और अगर मैं बाद में टाइप बदलने के लिए जाने का फैसला करता हूं, तो मुझे सभी चार मौकों को बदलना होगा।

असली दुनिया परिदृश्य में हम सैकड़ों बात कर रहे हैं, 4 नहीं। तो, यह हमेशा इसे अपनाने के लिए कोई ब्रेनर नहीं है, लेकिन यह निश्चित रूप से विचार करने योग्य है।

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

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

यह सब कहा जा रहा है कि, मैं स्वयं इस तरह के अमूर्तता का अक्सर उपयोग नहीं करता हूं।

Answer 2

मैं उस दर्शन से असहमत हूं। List<Person> एक प्रकार है जैसे PersonList है। व्यक्तियों की सूची की डोमेन अवधारणा भी इसमें शामिल है। यदि आप मुझसे पूछते हैं, तो जेनिक्स का जितना संभव हो उतना उपयोग करना बेहतर है जब तक कि उनका उपयोग न करें (नीचे देखें) या कोड को समझने में कठोर बनाता है। उदाहरण के लिए, PersonList पर काम करने वाला एक फ़ंक्शन List<Person> पर काम करने वाले एक से सामान्यीकृत करना कठिन होगा, अगर आप यह भी ध्यान दें कि यह कुछ सामान्य कर रहा है।

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

Answer 3

जो आप खोज रहे हैं वह typedef जावा या सी # के लिए ऑपरेटर है।

दुर्भाग्यवश subclassing दृष्टिकोण typedef के लिए एक अच्छा विकल्प नहीं है।

निम्नलिखित आलेख "Java theory and practice: The pseudo-typedef antipattern" बताता है कि पूर्ण विवरण में क्यों।

मैं उस लेख के शब्दशः निष्कर्ष यहां कॉपी जाएगा:

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