Compartilhar via

Implementação de interface explícita (guia de programação em C#)

Se uma classe implementar 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 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 de interface explicitamente. Uma implementação de interface explícita é um membro de classe que só é chamado por meio da interface especificada. Nomeie o membro da classe prefixando-o com o nome da interface e um período. 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 IControl.Paint classe só está disponível por meio da IControl interface e ISurface.Paint só está disponível por meio de ISurface. Ambas as implementações de método são separadas e nenhuma delas 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 com o mesmo nome, como uma propriedade e um método. Para implementar ambas as interfaces, uma classe precisa usar a implementação explícita para a propriedade Pou 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, pois não é acessível como um membro do tipo em que está definido. 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, receberá o erro do compilador CS0106. Para obter mais informações, consulte interface (Referência de 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 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