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

Se una classe implementa due interfacce che contengono un membro con la stessa firma e quest'ultimo viene implementato sulla classe, entrambe le interfacce utilizzeranno il membro come propria implementazione.Nell'esempio seguente, tutte le chiamate a Paint richiamare lo stesso metodo.

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 tuttavia due membri di interfaccia non eseguono la stessa funzione, l'implementazione di una o di entrambe le interfacce potrebbe non risultare corretta.È possibile implementare un membro di interfaccia in modo esplicito, ossia creando un membro di classe che viene chiamato solo tramite l'interfaccia e che è specifico di tale interfaccia.Per questa operazione è necessario assegnare al membro di classe il nome dell'interfaccia seguito da 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'interfaccia IControl, mentre ISurface.Paint è disponibile solo tramite ISurface.Entrambe le implementazioni del metodo sono distinte e nessuna è direttamente disponibile sulla classe.Ad esempio:

// Call the Paint methods from Main.

SampleClass obj = new SampleClass();
//obj.Paint();  // Compiler error.

IControl c = (IControl)obj;
c.Paint();  // Calls IControl.Paint on SampleClass.

ISurface s = (ISurface)obj;
s.Paint(); // Calls ISurface.Paint on SampleClass.

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

L'implementazione esplicita consente inoltre di risolvere i casi in cui due interfacce dichiarano membri diversi con lo stesso nome, ad esempio una proprietà e un metodo:

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

Per implementare entrambe le interfacce, una classe deve utilizzare l'implementazione esplicita per la proprietà P o il metodo P oppure per entrambi, in modo da evitare che venga generato un errore del compilatore.Ad esempio:

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

Vedere anche

Riferimenti

Classi e struct (Guida per programmatori C#)

Interfacce (Guida per programmatori C#)

Ereditarietà (Guida per programmatori C#)

Concetti

Guida per programmatori C#