Implementação de interface explícita (Guia de Programação em C#)Explicit Interface Implementation (C# Programming Guide)

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.If a class implements two interfaces that contain a member with the same signature, then implementing that member on the class will cause both interfaces to use that member as their implementation. No exemplo a seguir, todas as chamadas para Paint invocam o mesmo método.In the following example, all the calls to Paint invoke the same method. Este primeiro exemplo define os tipos:This first sample defines the types:

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:The following sample calls the methods:

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

Quando dois membros de interface não executam a mesma função, ele leva a uma implementação incorreta de uma ou de ambas as interfaces.When two interface members don't perform the same function, it leads to an incorrect implementation of one or both of the interfaces. É possível implementar um membro de interface explicitamente, criando um membro de classe que é chamado apenas por meio da interface e é específico para essa interface.It's possible to implement an interface member explicitly—creating a class member that is only called through the interface, and is specific to that interface. Nomeie o membro da classe com o nome da interface e um ponto final.Name the class member with the name of the interface and a period. Por exemplo:For example:

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.The class member IControl.Paint is only available through the IControl interface, and ISurface.Paint is only available through ISurface. Ambas as implementações de método são separadas e nenhuma está disponível diretamente na classe.Both method implementations are separate, and neither are available directly on the class. Por exemplo:For example:

// Call the Paint methods from Main.

SampleClass obj = new SampleClass();
//obj.Paint();  // Compiler error.

IControl c = obj;
c.Paint();  // Calls IControl.Paint on SampleClass.

ISurface s = obj;
s.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.Explicit implementation is also used to resolve cases where two interfaces each declare different members of the same name such as a property and a method. Para implementar ambas as interfaces, uma classe deve usar a implementação explícita para a propriedade P ou o método P , ou ambos, para evitar um erro do compilador.To implement both interfaces, a class has to use explicit implementation either for the property P, or the method P, or both, to avoid a compiler error. Por exemplo:For example:

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

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

A partir do C# 8,0, você pode definir uma implementação para membros declarados em uma interface.Beginning with C# 8.0, you can define an implementation for members declared in an interface. Se uma classe herdar uma implementação de método de uma interface, esse método só poderá ser acessado por meio de uma referência do tipo de interface.If a class inherits a method implementation from an interface, that method is only accessible through a reference of the interface type. O membro herdado não aparece como parte da interface pública.The inherited member doesn't appear as part of the public interface. O exemplo a seguir define uma implementação padrão para um método de interface:The following sample defines a default implementation for an interface method:

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:The following sample invokes the default implementation:

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 Paint método padrão, seja como um método público ou como uma implementação de interface explícita.Any class that implements the IControl interface can override the default Paint method, either as a public method, or as an explicit interface implementation.

Veja tambémSee also