C # में जेनेरिक प्रकारों के लिए एक अच्छा नामकरण सम्मेलन क्या है? [बन्द है]

Question

मैंने स्टैक ओवरफ्लो के बजाय यहां यह सवाल पूछने का फैसला किया क्योंकि यह व्यक्तिपरक है।

C # में, आमतौर पर मैं बहुत गरीब नामों के साथ सामान्य प्रकार देखता हूं। विशेष रूप से, "टी" का आमतौर पर उपयोग किया जाता है, लेकिन यह अपने आप में एक सार्थक नाम नहीं है। उदाहरण के लिए:

class Fruit<T>
{
    T fruit;
}

जबकि यह विशिष्ट दृष्टिकोण है, क्या कोई इसके खिलाफ सिफारिश करेगा? और यदि ऐसा है, तो जेनेरिक कार्यों और वर्गों के लिए सी # के संदर्भ में सामान्य प्रकार के लिए एक उचित नामकरण सम्मेलन क्या होगा?

मेरे पिछले उदाहरण में, मान लेते हैं कि जेनेरिक प्रकार Tहमेशा एक प्रकार का फल होना चाहिए, जैसे Appleया Orange। प्रकार Tको यह स्पष्ट करने की आवश्यकता है कि यह एक प्रकार का फल है, इसलिए शायद एक बेहतर नाम होगा FruitType, इसलिए हम इसके साथ समाप्त होते हैं:

class Fruit<FruitType>
{
    FruitType fruit;
}

यह सिर्फ आप लोगों को यह बताने का है कि मैं क्या देख रहा हूं। इस मुद्दे के लिए एक स्वीकार्य "अंगूठे का नियम" क्या है?

Comments

यह एक रचनात्मक सवाल नहीं है। यह केवल पोस्टर की पसंदीदा शैली के साथ उत्तर प्राप्त करेगा।

— माइकल के

अपने उदाहरण पर विचार करते हुए बाधाओं पर एक नज़र डालें: msdn.microsoft.com/en-us/library/d5x73970.aspx#Y426

— मैथ्यू

@ मायकिल में कई तरह के जवाब होंगे, और स्वीकृत जवाब रॉबर्ट का पसंदीदा होगा, लेकिन विभिन्न अन्य जवाबों को वोट दिया जाएगा।

— स्टुपरयूजर जूल

@ मीकल एक व्यक्तिपरक प्रश्न को एक व्यक्तिपरक उत्तर मिलता है। यह प्रश्न अभी भी रचनात्मक है क्योंकि यह किसी भी व्यक्ति के लिए एक संदर्भ बिंदु के रूप में कार्य करता है जो इस विशेष समस्या के लिए विभिन्न प्रकार के विचार / समाधान चाहता है। उत्तर के रूप में मैं जिस पर निशान लगाता हूं वह केवल एक और केवल उपयोगी जानकारी का प्रतिनिधित्व नहीं करता है।

— void.pointer

शायद इसे एक समुदाय विकी में बदल दें, एक अच्छा, यद्यपि व्यक्तिपरक, संसाधन के रूप में।

— tylermac

Answer 1

यह वास्तव में व्यक्तिपरक है ... ईश ।
जैसा कि कुछ लोग पाते हैं iकि लूप वेरिएबल के Tलिए पूरी तरह से वैध है , कुछ लोगों का मानना है कि जेनेरिक क्लास में टाइप करने वाले के लिए पूरी तरह से मान्य है।

मैं व्यक्तिगत रूप से इस दृष्टिकोण का समर्थन करता हूं, यह एक आम सम्मेलन है और लोग आमतौर पर जानते हैं कि आपका क्या मतलब है।

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

public class Dictionary<TKey, TValue>

हालांकि, टपल जैसी किसी चीज के लिए, जहां प्रकार अनिवार्य रूप से अर्थहीन हैं, मैं निम्नलिखित पूरी तरह से स्वीकार्य मानता हूं।

public class Tuple<T1, T2, T3>

Comments

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

— कोनराड रूडोल्फ

@Konrad: आप एक बिंदु है। । । हालाँकि प्रश्न को व्यक्तिपरक के रूप में टैग नहीं किया गया है, यह पूछने वाले ने स्वीकार किया कि यह एक व्यक्तिपरक विषय है जो यह कहता है कि लोगों का नामकरण सम्मेलनों पर अपनी प्राथमिकताएं हैं। इसलिए, जबकि प्रश्न व्यक्तिपरक नहीं हो सकता है (और तथ्य की बात के रूप में यह एक सही उत्तर नहीं है, यानी वह उत्तर जो Microsoft आधिकारिक दिशानिर्देश से लिंक है) विषय व्यक्तिपरक है, क्योंकि मुझे यकीन है कि कोई व्यक्ति पोस्ट करेगा " iऔर Tकर रहे हैं बुराई । एक एकल अक्षर के नाम कभी का उपयोग कभी नहीं करना चाहिए" प्रकार जवाब। सभी को संतृप्त करने में मदद करने के लिए एक ईश जोड़ा है :)

— बाइनरी वॉरियर जूल

मुझे लगता है कि इस पोस्ट में जोड़े गए टिप्पणियों से यह एक बहुत ही मूल्यवान प्रतिक्रिया है, हालाँकि इसका उत्तर बहुत ही उपयोगी है। Tजब हम बिना किसी बाधा के एक प्रकार के बारे में बात कर रहे हैं, तो TFruitसमझ में आता है क्योंकि यह मुझसे कहता है "बाधा के साथ कोई भी प्रकार यह एक फल है"। यह सामान्य प्रकार के मापदंडों के नामकरण के लिए एक अच्छा "नियम का अंगूठा" जैसा लगता है। धन्यवाद!!

— void.pointer

बस ध्यान दें, यह MSDN से लाइब्रेरी डेवलपर्स के लिए .NET फ्रेमवर्क डिज़ाइन दिशानिर्देशों के साथ संरेखित करता है । देखें: जेनेरिक टाइप पैरामीटर्स के नाम ।

— थॉमस

Answer 2

मुझे लगता है कि आप सही हैं, हालांकि टी काफी मानक बन गया है। यह संभवतः पुराने C ++ समय और "टी टाइप" के शब्द से उत्पन्न होता है। मैं इसे यथासंभव वर्णनात्मक होने के लिए एक अच्छा अभ्यास मानता हूं, लेकिन यह व्यक्तिपरक है।

आप एक उपसर्ग के रूप में टी का चयन कर सकते हैं, बहुत से लोग जैसे कि मैं इंटरफेस के लिए चुनता हूं। इस प्रकार

class Juice<TFruit> where TFruit...

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

इसका नकारात्मक पक्ष यह है कि यह तब बुरा लगता है जब प्रकार स्वयं टी से शुरू होता है। इसलिए मुझे लगता है कि यह विशेष मामलों में सामान्य प्रकार के प्रत्यय के लिए एक अच्छी बात होगी, जैसे नीचे।

class SomeAlgorithm<TypeT> where TypeT : Type

कृपया ध्यान दें कि यह सिर्फ मेरी राय है और अत्यधिक व्यक्तिपरक है। लेकिन मुझे लगता है कि मुझे प्रत्यय लगाने के लिए उपसर्ग पसंद करने के साथ एक मामूली बात मिली है।

Comments

Tप्रकार के मापदंडों के लिए और Iइंटरफ़ेस के नाम के लिए उपसर्ग का उपयोग फ्रेमवर्क डिज़ाइन दिशानिर्देशों में स्पष्ट रूप से आवश्यक है (" डीओ ..." नियम)।

— रिचर्ड

यह संदेहास्पद है कि TFruitयहां उपयोग करने से टेबल ओवर क्या हो जाता है T। नाम का उपयोग करना TTypeया TypeTनिश्चित रूप से बकवास है। यह कोई भी जानकारी जोड़ता है जो भी हो T। ठीक उसी जानकारी से अवगत कराया जाता है।

— कोनराड रुडोल्फ

@ कोनराड रूडोल्फ: टाइप टाइप के मेरे उदाहरण को करीब से देखें, यह System.Type के साथ काम करते समय एक विशेष मामले को कवर करता है। मुझे लगता है कि मेरे नाम में टाइप के लिए टी का उपयोग करने की तुलना में एक उच्च एन्ट्रापी है, खासकर अगर जेनेरिक भी विवश है।

— फाल्कन

Answer 3

Microsoft के पास जेनरिक के बारे में एक आधिकारिक दिशानिर्देश है: नाम, वर्ग, संरचना और इंटरफेस ( यहाँ उद्धृत , और पुस्तक रूप में: फ्रेमवर्क डिज़ाइन दिशानिर्देश )।

आपके विशिष्ट प्रश्न के बारे में यह कहता है:

वर्णनात्मक नामों के साथ सामान्य प्रकार के मापदंडों को नाम दें, जब तक कि एक-अक्षर का नाम पूरी तरह से स्व-व्याख्यात्मक न हो और एक वर्णनात्मक नाम मूल्य नहीं जोड़ेगा।

IDictionary<TKey, TValue> 

इस दिशानिर्देश का अनुसरण करने वाले इंटरफ़ेस का एक उदाहरण है।

एक एकल-अक्षर प्रकार पैरामीटर के साथ टाइप के लिए टाइप टी नाम के रूप में टी अक्षर का उपयोग करने पर विचार करें।

T के साथ वर्णनात्मक प्रकार के पैरामीटर नाम उपसर्ग करें।

पैरामीटर के नाम पर एक प्रकार के पैरामीटर पर रखी गई बाधाओं को इंगित करने पर विचार करें। उदाहरण के लिए, ISession के लिए विवश एक पैरामीटर को TSession कहा जा सकता है।

Comments

एक बेहतर संदर्भ MSDN पर फ्रेमवर्क डिज़ाइन गाइडलाइन्स बुक या सारांश (सारांश) होगा, विशेष रूप से वर्गों, संरचनाओं और इंटरफेस के नाम ।

— रिचर्ड

@ रिचर्ड: आपकी टिप्पणी को देखते हुए मेरे उत्तर को समायोजित कर दिया, धन्यवाद!

— Matthieu

Answer 4

जेनरिक का पूरा बिंदु कार्यक्षमता को सौंपना है - सामान्य वर्ग एक काम करता है, इसका तर्क दूसरा करता है। पाठ्यपुस्तक का उदाहरण एक सामान्य संग्रह है: संग्रह 'चीजें' संग्रहीत करता है, लेकिन यह परवाह नहीं करता है कि ये चीजें क्या हैं। जेनेरिक नाम (sic!), इस प्रकार, इसका एक निश्चित तर्क है - हम यह नहीं चाहते हैं कि यह वर्णनात्मक हो, क्योंकि "यह सामान्य प्रकार का तर्क" के अलावा कुछ भी वर्णन करने के लिए नहीं है, जिसका नाम बहुत अधिक है T(विचार करते हुए) सम्मेलन)। वर्णनात्मक होना अच्छा है, लेकिन अत्यधिक वर्णनात्मक होने से प्रतिबंधों का पता चलता है जो वहां नहीं हैं।

कभी-कभी, हालांकि, एक सामान्य वर्ग या विधि में एक से अधिक प्रकार के पैरामीटर होते हैं, और इस बिंदु पर, यह उन्हें और अधिक वर्णनात्मक नाम देने के लिए समझ में आता है, ताकि उनकी भूमिका स्पष्ट हो जाए। एक अच्छा उदाहरण एक कुंजी-मूल्य संग्रह प्रकार के लिए होगा, जहां कुंजी और मूल्य दोनों सामान्य हैं; उन्हें कॉल करना Tऔर S(या Qया जो भी) उन्हें कॉल करने की तुलना में कम उपयोगी होगा, कहते हैं, KeyTypeऔर ValueType, या, TKeyऔर TVal।

Answer 5

जवाब वास्तव में व्यक्तिपरक है। हालाँकि, इसमें एक प्रश्न के रूप में योग्यता है, क्योंकि कोड को स्व-दस्तावेज होना चाहिए, और हम संभवतः इसे करने के लिए कुछ बेहतर तरीके सीख सकते हैं।

निम्नलिखित कन्वेंशन मैंने सीखा है और निम्नलिखित हैं:

• सामान्य प्रकार के मापदंडों को कभी भी ठोस वर्गों के लिए गलत नहीं होना चाहिए। यह आम तौर पर Tजो कुछ भी इस प्रकार की परवाह किए बिना की एक प्रस्तावना को प्रोत्साहित करता है, बहुत इंटरफेस की तरह आम तौर पर के साथ पूर्वनिर्मित हैं I।

• एक वर्ग या विधि पर एकल सामान्य प्रकार के पैरामीटर को आमतौर पर लेबल किया जाना चाहिए T। यह लगभग सार्वभौमिक रूप से समझा जाने वाला कन्वेंशन है जो C ++ टेम्प्लेट में वापस आता है।

• एक ही वर्ग या विधि घोषणा पर कई सामान्य प्रकार के मापदंडों को सभी टी के साथ शुरू होना चाहिए, लेकिन कुछ संक्षिप्त लेकिन समझने योग्य साधनों द्वारा विभेदित किया जाना चाहिए। TInऔर TOut, उदाहरण के लिए, एक विधि के लिए सामान्य और अच्छी तरह से समझे जाने वाले GTPs हैं जो एक दृढ़ता से टाइप किए गए जेनेरिक इनपुट को स्वीकार करते हैं और एक दृढ़ता से टाइप किए गए जेनेरिक आउटपुट का उत्पादन करते हैं।

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

• एक विधि पर एक एकल सामान्य प्रकार, जो एक युक्त वर्ग के सामान्य प्रकार से भिन्न होता है, या तो एक वर्ग या विधि में कई प्रकारों के बारे में पिछले नियम का पालन कर सकता है, या यदि प्रकार भिन्न होने के अलावा अन्य बहुत ही भिन्न है, तो इसे एक अलग दिया जा सकता है एकल पत्र, अक्सर Uया V। यह फिर से C ++ टेम्प्लेट पर वापस डेटिंग सम्मेलन है।

• आप जो भी करना चाहते हैं, उसे लगातार बनाए रखें; एक वर्ग के लिए एक GTP Tऔर अगले पर लेबल न करें TParam, जब तक कि दूसरे वर्ग को पहले में Tउपलब्ध न होने के कारण दूसरे में नेस्टेड न किया जाए ।