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

  • Artículo

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

Pero es posible que no quiera que se llame a 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 de clase IControl.Paint solo está disponible a través de la interfaz IControl, y ISurface.Paint solo está disponible mediante ISurface. Las dos implementaciones de método son independientes, y ninguna está disponible 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 donde 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 mediante 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 interfaz IControl puede invalidar el método Paint predeterminado, ya sea como un método público, o bien como una implementación de interfaz explícita.

Consulte también