Implementación de interfaz explícita (Guía de programación de C#)

Si una clase implementa dos interfaces que contienen un miembro con la misma firma, la implementación de ese miembro en la clase hará que ambas interfaces usen ese miembro como implementación. En el ejemplo siguiente, todas las llamadas a Paint invocan el mismo método.

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

Sin embargo, s los miembros de dos interfaces no realizan la misma función, esto puede llevar a una implementación incorrecta de una o ambas interfaces. Es posible implementar un miembro de interfaz explícitamente, creando un miembro de clase que sólo se llama a través de la interfaz y es específico de ésta. Esto se puede llevar a cabo asignando al miembro de clase el nombre de la interfaz y un punto. Por ejemplo:

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

El miembro de clase IControl.Paint sólo está disponible a través de la interfaz IControl, mientras que ISurface.Paint sólo está disponible a través de ISurface. Ambas implementaciones de método son independientes y ninguna está directamente disponible en la clase. Por ejemplo:

// 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

La implementación explícita también se usa para resolver casos donde cada una de las dos interfaces declara miembros diferentes del mismo nombre como propiedad y método:

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

Para implementar ambas interfaces, una clase tiene que utilizar implementación explícita, ya sea para la propiedad P, el método P o ambos, con el fin de evitar un error del compilador. Por ejemplo:

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

Vea también

Referencia

Clases y structs (Guía de programación de C#)

Interfaces (Guía de programación de C#)

Herencia (Guía de programación de C#)

Conceptos

Guía de programación de C#