क्या सी # जेनेरिक में "डिफ़ॉल्ट" टाइप पैरामीटर के लिए कोई उचित दृष्टिकोण है?

Question

सी ++ टेम्पलेट्स में, कोई निर्दिष्ट कर सकता है कि एक निश्चित प्रकार पैरामीटर डिफ़ॉल्ट है। अर्थात। जब तक स्पष्ट रूप से निर्दिष्ट नहीं किया जाता है, तो यह टाइप टी

का उपयोग करेगा सी # में किया जा सकता है या अनुमानित किया जा सकता है?

मैं की तरह कुछ के लिए देख रहा हूँ:

public class MyTemplate<T1, T2=string> {} 

तो उस प्रकार का एक उदाहरण है कि स्पष्ट रूप से निर्दिष्ट नहीं है T2: अनिवार्य रूप से

MyTemplate<int> t = new MyTemplate<int>(); 

होगा:

MyTemplate<int, string> t = new MyTemplate<int, string>(); 

आखिरकार मैं ऐसे मामले को देख रहा हूं जिसमें एक टेम्पलेट है जो काफी व्यापक रूप से है sed, लेकिन मैं एक अतिरिक्त प्रकार पैरामीटर के साथ विस्तार करने पर विचार कर रहा हूँ। मैं अनुमान लगा सकता हूं, मुझे लगता है, लेकिन अगर मैं इस नस में अन्य विकल्प थे तो मैं उत्सुक था।

Answer 1

सबक्लासिंग सबसे अच्छा विकल्प है।

मैं अपने मुख्य सामान्य वर्ग उपवर्ग हैं: एक विशिष्ट वर्ग

class MyGeneric<T> : BaseGeneric<T, string>

यह एक ही स्थान पर (आधार वर्ग) में अपने तर्क रखने के लिए आसान हो जाता है के साथ

class BaseGeneric<T,U>

, लेकिन उपयोग विकल्पों दोनों प्रदान करना भी आसान है। कक्षा के आधार पर, ऐसा होने के लिए शायद बहुत कम अतिरिक्त काम की आवश्यकता है।

Answer 2

सी # ऐसी सुविधा का समर्थन नहीं करता है।

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

Answer 3

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

Answer 4

एक समाधान उपclassing है। इसके बजाय मैं इसका उपयोग करूंगा, फैक्ट्री विधियां (var कीवर्ड के साथ संयुक्त) है।

public class MyTemplate<T1,T2> 
{ 
    public MyTemplate(..args..) { ... } // constructor 
} 

public static class MyTemplate{ 

    public static MyTemplate<T1,T2> Create<T1,T2>(..args..) 
    { 
     return new MyTemplate<T1, T2>(... params ...); 
    } 

    public static MyTemplate<T1, string> Create<T1>(...args...) 
    { 
     return new MyTemplate<T1, string>(... params ...); 
    } 
} 

var val1 = MyTemplate.Create<int,decimal>(); 
var val2 = MyTemplate.Create<int>(); 

ऊपर के उदाहरण val2 में प्रकार MyTemplate<int,string>की है और नहीं एक प्रकार से व्युत्पन्न।

एक प्रकार class MyStringTemplate<T>:MyTemplate<T,string>MyTemplate<T,string> जैसा ही नहीं है। यह कुछ परिदृश्यों में कुछ समस्याएं पैदा कर सकता है। उदाहरण के लिए आप MyTemplate<T,string> से MyStringTemplate<T> का उदाहरण नहीं डाल सकते हैं।

Answer 5

आप भी तो

public class MyTemplate<T1, T2> { 
    public T1 Prop1 { get; set; } 
    public T2 Prop2 { get; set; } 
} 

public class MyTemplate<T1> : MyTemplate<T1, string>{}