Compartir a través de

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 su implementación. En el ejemplo siguiente, todas las llamadas a Paint invocan el mismo método. En este primer ejemplo se definen los tipos:

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");
    }
}

En el ejemplo siguiente se llama a los métodos:

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

Sin embargo, puede que no desee utilizar la misma implementación para las dos interfaces. Para llamar a otra implementación en función de la interfaz en uso, puede implementar un miembro de interfaz de forma explícita. Una implementación de interfaz explícita es un miembro de clase al que solo se llama a través de la interfaz especificada. Asigne al miembro de clase el nombre de la interfaz y un punto como prefijo. 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 IControl.Paint de clase solo está disponible a través de la IControl interfaz y ISurface.Paint solo está disponible a través de ISurface. Ambas implementaciones de método son independientes y tampoco están disponibles directamente en la clase . Por ejemplo:

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

La implementación explícita también se usa para resolver casos en los que dos interfaces declaran miembros diferentes del mismo nombre, como una propiedad y un método. 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. Por ejemplo:

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

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

Una implementación de interfaz explícita no tiene un modificador de acceso, ya que no es accesible como miembro del tipo en el que se define. En su lugar, solo es accesible cuando se llama a través de una instancia de la interfaz. Si especifica un modificador de acceso para una implementación de interfaz explícita, obtendrá el error del compilador CS0106. Para obtener más información, vea interface (Referencia de C#).

Puede definir una implementación para los miembros declarados en una interfaz. Si una clase hereda una implementación de método de una interfaz, ese método solo es accesible a través de una referencia del tipo de interfaz. El miembro heredado no aparece como parte de la interfaz pública. En el ejemplo siguiente se define una implementación predeterminada para un método de interfaz:

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

En el ejemplo siguiente se invoca la implementación predeterminada:

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

Cualquier clase que implemente la IControl interfaz puede invalidar el método predeterminado Paint , ya sea como un método público o como una implementación de interfaz explícita.

Consulte también