परोक्ष एक सामान्य <T> वापस टी के लिए कास्टिंग

Question

अगर मैं लिखना वर्ग MyGeneric<T> जैसा कोई सामान्य वर्ग एक अंतर्निहित टाइप करने के लिए टी डाली लिखने के लिए यह संभव है, इसलिए मैं की तरह सामान कर सकते हैं:

public class MyGeneric<T> 
{ 
... 
} 

public class GenericProperties 
{ 
    public MyGeneric<string> MyGenericString {get;set;} 

    public void UseMyGeneric() 
    { 
     string sTest = MyGenericString; 
     MyGenericString = "this is a test"; 
    } 
} 

यह संभव है ऑपरेटरों को अधिभारित करके ऐसा करें? मुझे पता है कि यह किया जा सकता है अगर मेरी कक्षा सामान्य नहीं थी ...

Answer 1

अच्छा, हाँ, लेकिन ज़ोंबी यीशु के प्यार के लिए ऐसा नहीं करते हैं। यह वास्तव में भ्रमित है। मुझे लगता है कि आप जेनेरिक के उद्देश्य को थोड़ा गलत समझ रहे हैं। इसका उपयोग उस वर्ग में किसी वर्ग को "चालू" करने के लिए नहीं किया जाता है, इसका उपयोग उस प्रकार (MyGenericString) को आपके इच्छित प्रकार के 'जागरूक' होने के लिए किया जाता है, विभिन्न प्रयोजनों के लिए (आमतौर पर वे संग्रह-आधारित उद्देश्यों) होते हैं।

Answer 2

हाँ .. लेकिन इसे अधिक न करें, इससे लोगों को भ्रमित कर दिया जाता है। मैं केवल इसे रैपर प्रकारों के लिए उपयोग करता हूं।

class Wrapper<T> 
{ 
    public T Value {get; private set;} 
    public Wrapper(T val) {Value = val;} 

    public static implicit operator T(Wrapper<T> wrapper) {return wrapper.Value;} 
    public static implicit operator Wrapper<T>(T val) {return new Wrapper<T>(val);} 
} 



var intWrapper = new Wrapper<int>(7); 
var usingIt = 7 * intWrapper; //49 

Wrapper<int> someWrapper = 9; //woohoo 

Answer 3

हाँ इसे का उपयोग संभव है अंतर्निहित Conversion Operator Overloading

class Program 
{ 
    static void Main(string[] args) 
    { 
     myclass<string> a = new myclass<string>(); 
     a.inner = "Hello"; 
     string b = a; 
     Console.WriteLine(b); 
    } 
} 

class myclass<T> 
{ 
    public T inner; 
    public myclass() 
    { 

    } 
    public static implicit operator T(myclass<T> arg1) 
    { 
     return arg1.inner; 
    } 
} 

Answer 4

अन्य लोगों ने कहा, कि कानूनी लेकिन खतरनाक है। ऐसे कई नुकसान हैं जिनमें आप आ सकते हैं। उदाहरण के लिए, तो फिर तुम कहना

C<object> c = new C<object>("hello"); 
object o = (object) c; 

क्या होता है मान लीजिए आप C<T> और टी के बीच एक उपयोगकर्ता-निर्धारित रूपांतरण ऑपरेटर परिभाषित? क्या आपका उपयोगकर्ता परिभाषित रूपांतरण चलता है या नहीं? नहीं, क्योंकि सी पहले से ही एक वस्तु है।

जैसा कि मैंने कहा, पागल स्थितियों में आप जेनेरिक रूपांतरण ऑपरेटरों को परिभाषित करने का प्रयास करते समय प्राप्त कर सकते हैं; तब तक ऐसा न करें जब तक कि विनिर्देश के खंड 10.10.3 की गहरी और विस्तृत समझ न हो।