.NET CLR आंतरिक रूप से "इंटरफेस" को कैसे कार्यान्वित करता है?

Question

इस बारे में उत्सुक है कि .NET CLR आंतरिक रूप से इंटरफेस को कैसे संभालता है?

Q1] क्या जब CLR की तरह कुछ का सामना करना पड़ता होता है: (। एक ही नीचे का इस्तेमाल किया)

simple interface example.

interface ISampleInterface 
    { 
     void SampleMethod(); 
    } 

    class ImplementationClass : ISampleInterface 
    { 
     // Explicit interface member implementation: 
     public void SampleMethod() 
     { 
      // Method implementation. 

     } 

     static void Main() 
     { 
      //Declare an interface instance. 
      ISampleInterface mySampleIntobj = new ImplementationClass(); // (A) 
      // Call the member. 
      mySampleIntobj.SampleMethod(); 

      // Declare an interface instance. 
      ImplementationClass myClassObj = new ImplementationClass(); // (B) 
      //Call the member. 
      myClassObj.SampleMethod(); 

     } 
    } 

Q2: ऊपर के उदाहरण कैसे हैं (ए) और (बी) अंतरित?

प्रश्न 3: Generic Interfaces अलग से इलाज किया गया है?

(एक noob की तरह लगता है जब इस तरह के बुनियादी सवाल पूछ ... वैसे भी ....)

सभी Thx।

Answer 1

कोड के उन बिट्स में व्यावहारिक रूप से कोई अंतर नहीं है। दोनों एक ही समारोह को बुलाते हैं। विधि प्रकार के माध्यम से विधि को कॉल करने में मामूली प्रदर्शन लाभ हो सकते हैं।

यदि आप यह चाहते हैं कि इन सामग्रियों को कैसे कार्यान्वित किया जाए, तो Virtual Method Tables पर एक नज़र डालें।

गहरी जानकारी के लिए, this देखें।

Answer 2

ऑब्जेक्ट रेफरेंस बनाते समय इंटरफ़ेस का उपयोग करना एक बेहतर अभ्यास माना जाता है, जो कि इसे क्लास प्रकार के साथ सीधे स्थापित करने की तुलना में बेहतर अभ्यास माना जाता है। यह एक इंटरफेस सिद्धांत के लिए प्रोग्रामिंग के तहत आता है।

इसका मतलब है कि आप कंक्रीट क्लास को बदल सकते हैं जो रनटाइम पर समान इंटरफेस लागू करता है जैसे कि निर्भरता इंजेक्शन या यहां तक ​​कि प्रतिबिंब भी हो सकता है। यदि आप कंक्रीट प्रकार के प्रोग्रामिंग की तुलना में इंटरफेस पर प्रोग्राम करते हैं तो आपके कोड को बदलने की आवश्यकता नहीं होगी।