Condividi tramite

Implementazione esplicita dell'interfaccia (Guida per programmatori C#)

Se una classe implementa due interfacce che contengono un membro con la stessa firma, l'implementazione di tale membro nella classe causerà l'utilizzo di tale membro da parte di entrambe le interfacce come implementazione. Nell'esempio seguente, tutte le chiamate per Paint richiamano lo stesso metodo. Questo primo esempio definisce i tipi:

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

L'esempio seguente chiama i metodi :

SampleClass sample = new SampleClass();
IControl control = sample;
ISurface surface = sample;

// The following lines all call the same method.
sample.Paint();
control.Paint();
surface.Paint();

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

Ma potrebbe non essere necessario chiamare la stessa implementazione per entrambe le interfacce. Per chiamare un'implementazione diversa a seconda dell'interfaccia in uso, è possibile implementare un membro dell'interfaccia in modo esplicito. Un'implementazione esplicita dell'interfaccia è un membro della classe chiamato solo tramite l'interfaccia specificata. Denominare il membro della classe anteponendogli il nome dell'interfaccia e un punto. Per esempio:

public class SampleClass : IControl, ISurface
{
    void IControl.Paint()
    {
        System.Console.WriteLine("IControl.Paint");
    }
    void ISurface.Paint()
    {
        System.Console.WriteLine("ISurface.Paint");
    }
}

Il membro IControl.Paint della classe è disponibile solo tramite l'interfaccia IControl ed ISurface.Paint è disponibile solo tramite ISurface. Entrambe le implementazioni del metodo sono separate e nessuno dei due è disponibile direttamente nella classe . Per esempio:

SampleClass sample = new SampleClass();
IControl control = sample;
ISurface surface = sample;

// The following lines all call the same method.
//sample.Paint(); // Compiler error.
control.Paint();  // Calls IControl.Paint on SampleClass.
surface.Paint();  // Calls ISurface.Paint on SampleClass.

// Output:
// IControl.Paint
// ISurface.Paint

L'implementazione esplicita viene usata anche per risolvere i casi in cui due interfacce dichiarano membri diversi con lo stesso nome, ad esempio una proprietà e un metodo. Per implementare entrambe le interfacce, una classe deve usare un'implementazione esplicita per la proprietà P, o il metodo Po entrambi, per evitare un errore del compilatore. Per esempio:

interface ILeft
{
    int P { get;}
}
interface IRight
{
    int P();
}

class Middle : ILeft, IRight
{
    public int P() { return 0; }
    int ILeft.P { get { return 0; } }
}

Un'implementazione esplicita dell'interfaccia non ha un modificatore di accesso perché non è accessibile come membro del tipo in cui è definito. È invece accessibile solo quando viene chiamato tramite un'istanza dell'interfaccia . Se si specifica un modificatore di accesso per un'implementazione esplicita dell'interfaccia, viene visualizzato l'errore del compilatore CS0106. Per altre informazioni, vedere interface (Riferimenti per C#).

È possibile definire un'implementazione per i membri dichiarati in un'interfaccia. Se una classe eredita un'implementazione del metodo da un'interfaccia, tale metodo è accessibile solo tramite un riferimento del tipo di interfaccia. Il membro ereditato non viene visualizzato come parte dell'interfaccia pubblica. L'esempio seguente definisce un'implementazione predefinita per un metodo di interfaccia:

public interface IControl
{
    void Paint() => Console.WriteLine("Default Paint method");
}
public class SampleClass : IControl
{
    // Paint() is inherited from IControl.
}

L'esempio seguente richiama l'implementazione predefinita:

var sample = new SampleClass();
//sample.Paint();// "Paint" isn't accessible.
var control = sample as IControl;
control.Paint();

Qualsiasi classe che implementa l'interfaccia può eseguire l'override IControl del metodo predefinito Paint , come metodo pubblico o come implementazione esplicita dell'interfaccia.

Vedere anche