जेनेरिक और प्रकार की बाधाओं के नियम

Question

जिज्ञासा से बाहर, क्यों संकलक टाइपिंग (ऑब्जेक्ट) से अलग किसी भी अलग तरह से एक अनियंत्रित जेनेरिक प्रकार का इलाज करता है?

class Bar { } 

class Foo 
{ 
    void foo(object thing) 
    { 
     ((Bar)thing).ToString(); 
    } 
} 

class Foo<T> 
{ 
    void foo(T thing) 
    { 
     ((Bar)thing).ToString(); 
    } 
} 

उपर्युक्त में, बार में "टी चीज" कास्टिंग एक संकलक त्रुटि में परिणाम देता है। बार में "ऑब्जेक्ट चीज" कास्टिंग करना हालांकि कुछ ऐसा है जो संकलक मुझे अपने जोखिम पर ही करने देता है।

जो मैं नहीं देखता वह क्यों है। .NET ऑब्जेक्ट में सभी के बाद कैच-सब है और रन-टाइम प्रकार बॉक्स किए गए मान या किसी भी प्रकार का ऑब्जेक्ट हो सकता है। तो मुझे नहीं लगता कि कंपाइलर के लिए दो मामलों के बीच अंतर करने के लिए तर्कसंगत कारण क्या है। सबसे अच्छा मैं ऐसा कर सकता हूं जैसे "प्रोग्रामर संकलक से जेनेरिक प्रकारों के साथ टाइपिंग करने की अपेक्षा करेगा, लेकिन ऑब्जेक्ट के साथ नहीं।" :) क्या यही सबकुछ है इसमें है?

Btw, मैं बस

((Bar)(object)thing).ToString(); 

लिख कर पता है कि मैं अभी भी अपने कलाकारों, फू मामले में किया प्राप्त कर सकते हैं कर रहा हूँ मैं सिर्फ समझने के लिए क्यों संकलक करता चाहते हैं ...

Answer 1

यहां महत्व object है। यदि पहला उदाहरण object के अलावा कुछ भी था, तो यह वही व्यवहार करेगा। असल में, क्या तुम यहाँ इस समय कह रहे हैं:

(Bar)thing 

है: "एक Bar करने के लिए एक T कन्वर्ट"; जो सामान्य मामले में कहीं भी कानूनी नहीं है। object जोड़कर आप यह कर:

(Bar)(object)thing 

है जो "एक object करने के लिए एक T परिवर्तित ..." - जो हमेशा कानूनी है, के बाद से object सभी प्रबंधित प्रकार की जड़ है; और ध्यान दें कि यह एक बॉक्स को आमंत्रित कर सकता है - "... और फिर object को Bar के रूप में डालें" - फिर से; यह संकलन समय पर हमेशा कानूनी होता है, और रनटाइम पर एक प्रकार-चेक ("अनबॉक्स-कोई भी") शामिल होता है।

उदाहरण के लिए: मान लीजिए TDateTime है ...

DateTime thing = ... 
Bar bar = (Bar)(object)thing; 

पूरी तरह से वैध है; सुनिश्चित करें कि यह रनटाइम पर असफल हो जाएगा, लेकिन: यह वह परिदृश्य है जिसे आपको ध्यान में रखने की आवश्यकता है।

Answer 2

यह जेनेरिक बनाने का अर्थशास्त्र और उद्देश्य नीचे आता है। यदि आपके पास सामान्य प्रकार टी है, तो संकलक आपको मनमाने ढंग से इसे किसी अन्य ऑब्जेक्ट पर सीधे नहीं डालने देगा। यह समझ में आता है क्योंकि टी का उद्देश्य प्रोग्रामर को यह निर्दिष्ट करने के लिए मजबूर करना है कि टी वास्तव में किस प्रकार का है। यह "ऑब्जेक्ट" नहीं होने वाला है, यह ऑब्जेक्ट का एक विशिष्ट प्रकार होगा। संकलन समय पर, संकलक नहीं जानता कि टी में क्या होने जा रहा है और इसलिए इसे कास्ट नहीं किया जा सकता है।

ऑब्जेक्ट से कास्टिंग एक अज्ञात ऑब्जेक्ट के रूप में काम करता है - जैसा कि किसी KNOWN ऑब्जेक्ट प्रकार का विरोध करता है जो उसके उपयोग में परिभाषित हो जाता है।

इसे "कहां" खंड के साथ बढ़ाया जा सकता है। जैसे, आप निर्दिष्ट कर सकते हैं कि टी आईबीआर प्रकार का होना चाहिए;

interface IBar { } 

class Bar : IBar { } 

class Foo<T> 
    where T : IBar 
{ 
    void foo(T thing) 
    { 
     ((IBar)thing).ToString(); 
    } 
} 

विरासत भी खंड के साथ काम करता है;

class Bar { } 

class Foo<T> 
    where T : Bar 
{ 
    void foo(T thing) 
    { 
     // now you don't need to cast at all as the compiler knows 
     // exactly what type T is (at a parent level at least) 
     thing.ToString(); 
    } 
}