Implementación de interfaz explícita (Guía de programación de C#)Explicit Interface Implementation (C# Programming Guide)

Si una clase implementa dos interfaces que contienen un miembro con la misma firma, entonces al implementar ese miembro en la clase ambas interfaces usarán ese miembro como su implementación.If a class implements two interfaces that contain a member with the same signature, then implementing that member on the class will cause both interfaces to use that member as their implementation. En el ejemplo siguiente, todas las llamadas a Paint invocan el mismo método.In the following example, all the calls to Paint invoke the same method.

class Test 
{
    static void Main()
    {
        SampleClass sc = new SampleClass();
        IControl ctrl = sc;
        ISurface srfc = 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

En cambio, si los dos miembros de interfaz no realizan la misma función, esto puede provocar una implementación incorrecta de una o ambas interfaces.If the two interface members do not perform the same function, however, this can lead to an incorrect implementation of one or both of the interfaces. Es posible implementar un miembro de interfaz explícitamente, mediante la creación de un miembro de clase que solo se llama a través de la interfaz, y es específico de esa interfaz.It is possible to implement an interface member explicitly—creating a class member that is only called through the interface, and is specific to that interface. Esto se consigue asignando un nombre al miembro de clase con el nombre de la interfaz y un período.This is accomplished by naming the class member with the name of the interface and a period. Por ejemplo:For example:

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 solo está disponible a través de la interfaz IControl, y ISurface.Paint solo está disponible mediante ISurface.The class member IControl.Paint is only available through the IControl interface, and ISurface.Paint is only available through ISurface. Ambas implementaciones de método son independientes, y ninguna está disponible directamente en la clase.Both method implementations are separate, and neither is available directly on the class. Por ejemplo:For example:

// Call the Paint methods from Main.

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

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

ISurface s = 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 dos interfaces declaran miembros diferentes del mismo nombre como una propiedad y un método:Explicit implementation is also used to resolve cases where two interfaces each declare different members of the same name such as a property and a method:

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

Para implementar ambas interfaces, una clase tiene que usar la implementación explícita para la propiedad P, o el método P o ambos, para evitar un error del compilador.To implement both interfaces, a class has to use explicit implementation either for the property P, or the method P, or both, to avoid a compiler error. Por ejemplo:For example:

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

Vea tambiénSee also