In C#, perché le implementazioni di interfaccia devono implementare esplicitamente un'altra versione di un metodo?

Question

Prendete questo esempio:

public interface IFoo 
{ 
    IFoo Bar(); 
} 

public class Foo : IFoo 
{ 
    public Foo Bar() 
    { 
     //... 
    } 

    IFoo IFoo.Bar() { return Bar(); } //Why is this necessary? 
} 

Perché l'implicita implementazione di IFoo Bar() necessaria anche se Foo converte in IFoo senza un cast?

Answer 1

È possibile risolvere in questo modo (un po 'brutto, ma si prende cura della tipizzazione forte):

public interface IFoo<T> where T : IFoo<T> 
{ 
    T Bar(); 
} 

public class Foo : IFoo<Foo> 
{ 
    public Foo Bar() 
    { 
     //... 
    } 
} 

Answer 2

Perché non sempre si desidera che il metodo che implementa l'interfaccia si comporti allo stesso modo di un'altra versione del metodo con la stessa firma.

Si consiglia inoltre a una classe di implementare un metodo per un'interfaccia, ma affinché tale metodo non sia accessibile da un'istanza della classe stessa.

Answer 3

Microsoft ha uno detailed write up sull'argomento ma si riduce all'implementazione di più interfacce/classi che hanno lo stesso metodo in esse. Implicito non funziona più in quel contesto.

class Test 
{ 
    static void Main() 
    { 
     SampleClass sc = new SampleClass(); 
     IControl ctrl = (IControl)sc; 
     ISurface srfc = (ISurface)sc; 

     // The following lines all call the same method. 
     sc.Paint(); 
     ctrl.Paint(); 
     srfc.Paint(); 
    } 
} 


interface IControl 
{ 
    void Paint(); 
} 
interface ISurface 
{ 
    void Paint(); 
} 
class SampleClass : IControl, ISurface 
{ 
    // Both ISurface.Paint and IControl.Paint call this method. 
    public void Paint() 
    { 
     Console.WriteLine("Paint method in SampleClass"); 
    } 
} 

// Output: 
// Paint method in SampleClass 
// Paint method in SampleClass 
// Paint method in SampleClass 

Se dovessimo prendere l'approccio esplicito, finiamo con questo.

Tutto si riduce alla fornitura di unicità quando i tipi implementati si scontrano. Nel tuo esempio, FooèIFoo.

Answer 4

E' necessario in questo caso perché C# non supporta tipo di ritorno covarianza per le interfacce, così la funzione

public Foo Bar() 
{ 
    //... 
} 

non soddisfa l'interfaccia IFoo in quanto il tipo di ritorno del metodo Bar è diverso.

Poiché si desidera implementare anche l'interfaccia, l'unica possibilità è di farlo in modo esplicito poiché si dispone già di un metodo Bar() definito sulla classe.

Answer 5

Si consiglia di mantenere l'implementazione implicita come protetta anziché pubblica.

public class Foo : IFoo 
{ 
    **protected virtual** Foo Bar() 
    { 
     //... 
    } 

    IFoo IFoo.Bar() { return Bar(); } 
} 

c'è una risposta piuttosto esteso del perché/quando usare esplicita implementazione in questa discussione:

implicit vs explicit interface implementation

Una buona ragione per utilizzare l'implementazione esplicita è che si può facilmente utilizzare l'iniezione di dipendenza avere un accoppiamento più libero quando usi la tua classe Foo.