Implementação de interface explícita em C#

Resumo : neste tutorial, você aprenderá sobre a implementação de interface explícita em C# e como usá-la de maneira eficaz.

Introdução à implementação de interface explícita em C#

Em C#, uma classe pode implementar uma interface de duas maneiras: implícita e explicitamente. Por padrão, C# usa a implementação implícita. Por exemplo:

interface ILogger
{
    void Log(string message);
}

class ConsoleLoger : ILogger
{
    public void Log(string message) => Console.WriteLine(message);
}

class Program
{
    public static void Main(string[] args)
    {
        var logger = new ConsoleLoger();
        logger.Log("Hello");
    }
}Linguagem de código:  C#  ( cs )

Neste exemplo, definimos uma ILoggerinterface com um método chamado Log, que registra uma mensagem. Em seguida, definimos uma ConsoleLoggerclasse que implementa a ILoggerinterface. A ConsoleLoggerclasse implementa o Logmétodo que registra uma mensagem no console.

No Main()método da Programclasse, criamos uma nova instância da ConsoleLoggerclasse e registramos uma mensagem no console.

Ao contrário da implementação de interface implícita, uma implementação de interface explícita exige que você especifique o nome da interface ao implementar o método. Por exemplo:

interface ILogger
{
    void Log(string message);
}

class ConsoleLoger : ILogger
{
    void ILogger.Log(string message) => Console.WriteLine(message);
}

class Program
{
    public static void Main(string[] args)
    {
        ILogger logger = new ConsoleLoger();
        logger.Log("Hello");
    }
}Linguagem de código:  C#  ( cs )

Neste exemplo, o ConsoleLoggerimplementa a ILoggerinterface explicitamente. Portanto, prefixamos o nome da interface antes do nome do método, separados por um ponto (.). Além disso, não usamos um modificador de acesso ( public) para o Logmétodo no arquivo ConsoleLogger.

No Main()método da Programclasse, só podemos acessar o Logmétodo através da ILoggerinterface. A razão é que o Logmétodo pertence à ILoggerinterface, não à ConsoleLoggerclasse, embora o implementemos na ConsoleLoggerclasse.

Esta também é a razão pela qual o Logmétodo não possui o publicmodificador de acesso. Em outras palavras, você não pode chamar o Logmétodo através de uma instância da ConsoleLoggerclasse.

Portanto, o código a seguir não será compilado e resultará em erro:

ConsoleLoger logger = new ConsoleLoger();
logger.Log("Hello"); // errorLinguagem de código:  C#  ( cs )

Quando usar a implementação de interface explícita em C#

A implementação explícita da interface permite evitar conflitos de nomenclatura entre múltiplas interfaces.

Já que uma classe pode implementar múltiplas interfaces e essas interfaces podem ter membros com o mesmo nome. Para evitar o conflito de nomenclatura, você pode usar a implementação explícita da interface.

O exemplo a seguir demonstra como usar a implementação explícita da interface:

interface IWritable
{
    void Write(string message);
}

interface ISavable
{
    void Write(string message);
}

class TextFile : IWritable, ISavable
{
    public string FileName  {  get;  set; }
    public TextFile(string filename)
    {
        FileName = filename;
    }
    void IWritable.Write(string message) => Console.WriteLine(message);
    void ISavable.Write(string message) => File.WriteAllText(FileName, message);
}

class Program
{
    public static void Main(string[] args)
    {
        var textFile = new TextFile(@"C:\temp\test.txt");
        ISavable savable = textFile;
        savable.Write("Hello");

        IWritable writable = textFile;
        writable.Write("Hello");

    }
}Linguagem de código:  C#  ( cs )

Como funciona.

Primeiro, defina a interface IWritablee ISavableque possui o mesmo método Write.

Segundo, defina a TextFileclasse que implementa ambas IWritableas ISavableinterfaces explicitamente.

Terceiro, crie uma nova instância de TextFilee chame o método Write das interfaces via ISavablee IWritableinterface respectivamente.

O programa grava a Hellomensagem no console e em um C:\temp\test.txtarquivo.

Resumo

A implementação explícita de interface fornece uma maneira de implementar métodos de interface com um prefixo de interface específico ( interfaceName.methodName).
A implementação explícita de interface é útil quando você tem uma classe que implementa múltiplas interfaces com o mesmo nome de método ou quando deseja evitar conflitos de nomenclatura entre interface e métodos de classe.
A implementação explícita da interface garante que o método só possa ser acessado através da interface à qual pertence.