Implementação de Interface Explícita (Guia de Programação em C#)

  • Artigo

Se uma classe implementa duas interfaces que contêm um membro com a mesma assinatura, a implementação desse membro na classe fará com que ambas as interfaces usem esse membro como sua implementação. No exemplo a seguir, todas as chamadas para Paint invocar o mesmo método. Este 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 da interface explicitamente. Uma implementação de interface explícita é um membro de classe que só é chamado através da interface especificada. Nomeie o membro da 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 IControl.Paint da classe só está disponível através da interface e ISurface.Paint só está disponível através do IControlISurface. Ambas as implementações de método são separadas e nenhuma está disponível diretamente 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 é usada para resolver casos em que duas interfaces declaram membros diferentes do mesmo nome, como uma propriedade e um método. Para implementar ambas as interfaces, uma classe tem que usar a implementação explícita para a propriedade P, ou o método P, ou ambos, para 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, uma vez que não é acessível como um membro do tipo em que está definida. Em vez disso, ele só é acessível 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, obterá o erro de compilador CS0106. Para obter mais informações, consulte interface (Referência C#).

Você pode definir uma implementação para membros declarados em uma interface. Se uma classe herda uma implementação de método de uma interface, esse método só é acessível através 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 implemente a IControl interface pode substituir o método padrão Paint , seja como um método público ou como uma implementação de interface explícita.

Consulte também