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

  • Articolo

Se class implementa due interfacce che contengono un membro con la stessa firma e quest'ultimo viene implementato nella classe, entrambe le interfacce useranno il membro come propria implementazione. Nell'esempio seguente tutte le chiamate a 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 anteponendo il nome dell'interfaccia e un punto. Ad esempio:

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

Il membro di classe IControl.Paint è disponibile solo tramite l'interfacciaIControl e ISurface.Paint è disponibile solo tramite ISurface. Entrambe le implementazioni del metodo sono separate e nessuno dei due è disponibile direttamente nella classe . Ad 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. Ad 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.

Vedi anche