Implementação de interface explícita (Guia de Programação em C#)

  • Artigo

Caso uma classe implemente duas interfaces que contêm um membro com a mesma assinatura, logo, implementar esse membro na classe fará com que as duas interfaces usem tal membro como sua implementação. No exemplo a seguir, todas as chamadas para Paint invocam o mesmo método. Esse primeiro exemplo define os 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");
    }
}

O exemplo a seguir chama os 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

Mas talvez você não queira que a mesma implementação seja chamada para ambas as interfaces. Para chamar uma implementação diferente dependendo de qual interface está em uso, você pode implementar um membro de interface explicitamente. Uma implementação de interface explícita é um membro de classe que só é chamado por meio da interface especificada. Nomeia o membro de classe prefixando-o com o nome da interface e um ponto. Por exemplo:

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

O membro da classe IControl.Paint está disponível somente por meio da interface IControl e ISurface.Paint está disponível apenas por meio do ISurface. Ambas as implementações de método são separadas e nenhuma delas está diretamente disponível na classe. Por exemplo:

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

A implementação explícita também é utilizada para resolver casos em que duas interfaces declaram membros diferentes com o mesmo nome, como uma propriedade e um método. Para implementar as duas interfaces, é necessário que uma classe use a implementação explícita para a propriedade P, o método P ou ambos, a fim de evitar um erro do compilador. Por exemplo:

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

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

Uma implementação de interface explícita não tem um modificador de acesso, pois não está acessível como membro do tipo em que está definido. Em vez disso, ele só pode ser acessado quando chamado por meio de uma instância da interface. Se você especificar um modificador de acesso para uma implementação de interface explícita, receberá o erro do compilador CS0106. Para obter mais informações, confira interface (referência C#).

Você pode definir uma implementação para membros declarados em uma interface. Se uma classe herdar uma implementação de método de uma interface, esse método só será acessível por meio de uma referência do tipo de interface. O membro herdado não aparece como parte da interface pública. O exemplo a seguir define uma implementação padrão para um método de interface:

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

O exemplo a seguir invoca a implementação padrão:

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

Qualquer classe que implementa a interface IControl pode substituir o método padrão Paint, seja como um método público, seja como uma implementação de interface explícita.

Confira também