In che modo .Net CLR implementa internamente un'interfaccia?

Question

Solo curiosità su come .NET CLR gestisce le interfacce internamente?

Q1] Cosa accade quando CLR incontra qualcosa come: (. Stessa usata sotto)

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: Nell'esempio precedente come sono (A) e (B) differenziato?

Q3: lo Generic Interfaces è trattato in modo diverso?

(sento come un niubbo quando si fanno domande di base come questi ... comunque ....)

Thx tutti.

Answer 1

Non ci sono praticamente differenze in quei bit di codice. Entrambi finiscono per chiamare la stessa funzione. Potrebbero esserci minori vantaggi in termini di prestazioni nel chiamare il metodo attraverso il tipo di classe.

Se si desidera come sono implementate queste cose, dare un'occhiata a Virtual Method Tables.

Per informazioni più dettagliate, vedere this.

Answer 2

L'utilizzo dell'interfaccia durante la creazione del riferimento all'oggetto è considerato una pratica migliore rispetto al suo instradamento diretto con un tipo di classe. Questo rientra nella programmazione di un principio di interfaccia.

Ciò significa che è possibile modificare la classe concreta che implementa la stessa interfaccia in fase di esecuzione utilizzando qualcosa come l'iniezione di dipendenza o addirittura può essere una riflessione. Non sarà necessario modificare il codice se si programma su un'interfaccia rispetto alla programmazione su un tipo concreto.