.NET जेनेरिक शब्दावली - खुला/बंद, अनबाउंड/निर्मित

Question

.NET जेनेरिक शब्दावली थोड़ा अस्पष्ट है। इससे भी बदतर - ऐसा लगता है कि विभिन्न स्रोतों में अस्पष्टतापूर्वक और अलग-अलग इस्तेमाल किया जाता है। क्या मूल रूप से स्पष्ट नहीं है इन 4 शब्दों के बीच रिश्तों ("प्रकार" के संबंध में) है:

1. खुला
2. बंद कर दिया
3. अनबाउंड
4. निर्माण

मैं समझता हूँ List<T> है कि खुला और List<int> बंद है। लेकिन खुले/बंद प्रकारों के संबंध में वास्तव में "निर्मित" और "अनबाउंड" क्या है?

Answer 1

language specification से:

4,4 निर्माण प्रकार

एक सामान्य प्रकार घोषणा, अपने आप में, एक अनबाउंड सामान्य प्रकार कि बनाने के लिए एक "खाका" के रूप में प्रयोग किया जाता है को दर्शाता है विभिन्न प्रकार, लागू करने के तरीके से विभिन्न प्रकार टाइप करें। टाइप तर्क कोण ब्रैकेट्स (< और>) जेनेरिक प्रकार के नाम के तुरंत बाद लिखे गए हैं। एक प्रकार जिसमें कम से कम एक प्रकार का तर्क शामिल है उसे निर्मित प्रकार कहा जाता है। भाषा में अधिकांश स्थानों में एक निर्मित प्रकार का उपयोग किया जा सकता है जिसमें एक प्रकार का नाम दिखाई दे सकता है। एक अनबाउंड सामान्य प्रकार केवल टाइप-अभिव्यक्ति (§7.6.11) के भीतर उपयोग किया जा सकता है। [...]

4.4.2 खुला और बंद प्रकार

सभी प्रकार के या तो खुला प्रकार या बंद प्रकार रूप में वर्गीकृत किया जा सकता है। एक खुला प्रकार एक प्रकार है जिसमें पैरामीटर शामिल हैं। अधिक विशेष रूप से:

• प्रकार पैरामीटर एक खुले प्रकार को परिभाषित करता है।

• एक सरणी प्रकार एक खुला प्रकार है यदि केवल तभी होता है यदि इसका तत्व प्रकार खुला प्रकार है।

• एक निर्मित प्रकार एक खुला प्रकार है और यदि केवल प्रकार तर्क तर्क एक खुला प्रकार है। निर्मित नेस्टेड प्रकार एक खुला प्रकार है और केवल तभी होता है जब तर्क टाइप करें या इसके प्रकार के प्रकार इसके प्रकार के प्रकार प्रकार हैं।

एक बंद प्रकार एक प्रकार है जो खुला प्रकार नहीं है। [...]

4.4.3 बाउंड और अबाध प्रकार

अवधि अनबाउंड प्रकार एक गैर सामान्य प्रकार या एक अबाध सामान्य प्रकार को दर्शाता है। अवधि बाध्य प्रकार एक गैर सामान्य प्रकार या एक का निर्माण किया प्रकार को दर्शाता है। एक अनबाउंड प्रकार इकाई को एक प्रकार की घोषणा द्वारा घोषित किया गया है। एक अबाध सामान्य प्रकार एक प्रकार ही नहीं है, और या एक चर, तर्क के प्रकार के रूप में इस्तेमाल नहीं किया जा सकता मान, या एक आधार प्रकार के रूप में। केवल बनाएं जिसमें एक अबाध सामान्य प्रकार संदर्भित किया जा सकता typeof अभिव्यक्ति (§7.6.11) है।

---

यहाँ एक उदाहरण मैं के बारे में सोचा है:

// Foo<T> is an unbound generic type. 
class Foo<T> { .. } 

// Bar<K> is an unbound generic type. 
// Its base-class Foo<K> is a constructed, open generic type. 
class Bar<K> : Foo<K> { .. } 

// IntFoo is not a generic type. 
// Its base-class Foo<int> is a constructed, closed generic type. 
class IntFoo : Foo<int> { .. } 

---

और यहाँ में टाई कि प्रतिबिंब एपीआई के साथ एक प्रयास, प्रासंगिक गुण का उपयोग कर रहा है: IsGenericType, IsGenericTypeDefinition और ContainsGenericParameters

(इन परीक्षणों प्रत्येक "प्रकार" की 100% भविष्य कहनेवाला भाषा कल्पना के अनुसार नहीं हैं)।

+----------+---------------------+-----------+--------------+-------------------+ 
| Name |  Kind   | IsGenType | IsGenTypeDef | ContainsGenParams | 
+----------+---------------------+-----------+--------------+-------------------+ 
| Foo<> | Unbound    | TRUE  | TRUE   | TRUE    | 
| Foo<>* | Constructed, open | TRUE  | FALSE  | TRUE    | 
| Foo<int> | Constructed, closed | TRUE  | FALSE  | FALSE    | 
| IntFoo | Not generic   | FALSE  | FALSE  | FALSE    | 
+----------+---------------------+-----------+--------------+-------------------+ 
* = Bar<>'s base type.