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

Se classe implementa duas interfaces que contém um membro com a mesma assinatura, então implementar o membro na classe fará com que as duas interfaces usa esse membro como sua implementação. No exemplo, todas as chamadas a Paint chamam o mesmo método.

class Test 
{
    static void Main()
    {
        SampleClass sc = new SampleClass();
        IControl ctrl = (IControl)sc;
        ISurface srfc = (ISurface)sc;

        // The following lines all call the same method.
        sc.Paint();
        ctrl.Paint();
        srfc.Paint();
    }
}


interface IControl
{
    void Paint();
}
interface ISurface
{
    void Paint();
}
class SampleClass : IControl, ISurface
{
    // Both ISurface.Paint and IControl.Paint call this method.  
    public void Paint()
    {
        Console.WriteLine("Paint method in SampleClass");
    }
}

// Output: 
// Paint method in SampleClass 
// Paint method in SampleClass 
// Paint method in SampleClass

Se os dois membros de interface não executam a mesma função, o entanto, isso pode levar a uma implementação incorreta de uma ou ambas a interfaces. É possível implementar um membro de interface que cria um membro da classe que é chamado somente através da interface, e é específico à interface. Isso é feito nomeando o membro da classe 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 só está disponível através da interface de IControl , e ISurface.Paint é somente ISurfacedireto disponível. Ambas as implementações do método são separadas, e nenhuma está disponível diretamente na classe. Por exemplo:

// Call the Paint methods from Main.

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

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

ISurface s = (ISurface)obj;
s.Paint(); // Calls ISurface.Paint on SampleClass. 

// Output: 
// IControl.Paint 
// ISurface.Paint

A implementação explícita também é usada para resolver os casos onde duas interfaces cada declarar membros diferentes do mesmo nome como uma propriedade e um método:

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

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:

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

Consulte também

Referência

Classes e structs (Guia de Programação em C#)

Interfaces (Guia de Programação em C#)

Herança (Guia de Programação em C#)

Conceitos

Guia de Programação em C#