Interfaces Explícitas

Parte da seção Programação Orientada a Objetos do Journey de C# da Coddy — lição 28 de 70.

Quando uma classe implementa múltiplas interfaces que possuem membros com o mesmo nome, você enfrenta uma colisão de nomes. A implementação explícita de interface resolve isso permitindo que você forneça implementações separadas para cada interface.

Com a implementação explícita, você prefixa o nome do membro com o nome da interface e omite o modificador de acesso:

public interface IAmericanPlug
{
    void Connect();
}

public interface IEuropeanPlug
{
    void Connect();
}

public class UniversalAdapter : IAmericanPlug, IEuropeanPlug
{
    void IAmericanPlug.Connect()
    {
        Console.WriteLine("Connected to 120V");
    }
    
    void IEuropeanPlug.Connect()
    {
        Console.WriteLine("Connected to 220V");
    }
}

Membros implementados explicitamente só podem ser acessados por meio de uma variável do tipo interface, não por meio da própria classe:

var adapter = new UniversalAdapter();
// adapter.Connect();  // Não vai compilar!

IAmericanPlug american = adapter;
american.Connect();  // Conectado a 120V

IEuropeanPlug european = adapter;
european.Connect();  // Conectado a 220V

Esta técnica também é útil quando você deseja ocultar membros da interface da API pública da classe. Se um método só faz sentido ao tratar o objeto como uma interface específica, a implementação explícita mantém a área de superfície da sua classe limpa, ao mesmo tempo que cumpre o contrato.

Desafio

Fácil

Vamos construir um sistema gerador de relatórios que demonstra como a implementação explícita de interface permite que uma única classe forneça comportamentos diferentes dependendo de qual interface está sendo usada. Você criará um documento que pode ser formatado de forma diferente para exibição em comparação com a impressão.

Você organizará seu código em quatro arquivos:

IDisplayable.cs: Defina uma interface chamada IDisplayable no namespace Reports. Esta interface representa o conteúdo que pode ser mostrado na tela. Ela deve declarar um método Render() que retorna uma string.
IPrintable.cs: Defina uma interface chamada IPrintable no namespace Reports. Esta interface representa o conteúdo que pode ser enviado para uma impressora. Ela também deve declarar um método Render() que retorna uma string - observe que isso cria uma colisão de nomes com IDisplayable!
Report.cs: Defina uma classe Report no namespace Reports que implementa tanto IDisplayable quanto IPrintable. O relatório deve ter uma propriedade Title (string) e uma propriedade Content (string), com um construtor que define ambos os valores. Use a implementação explícita de interface para fornecer diferentes comportamentos de Render():
- Quando renderizado para exibição: "[SCREEN] {Title}: {Content}"
- Quando renderizado para impressão: "[PRINT] {Title} | {Content}"
Program.cs: No seu arquivo principal, crie um Report usando os valores de entrada. Como as implementações explícitas só podem ser acessadas através de variáveis de interface, armazene o mesmo relatório em uma variável IDisplayable e em uma variável IPrintable, então chame Render() em cada uma para mostrar como o mesmo objeto produz saídas diferentes com base em qual interface você está usando.

Você receberá duas entradas:

Título do relatório
Conteúdo do relatório

Imprima a saída neste formato:

Display version:
{Render() via IDisplayable}
Print version:
{Render() via IPrintable}

Por exemplo, se as entradas forem Sales Report e Q4 revenue increased by 15%, a saída deve ser:

Display version:
[SCREEN] Sales Report: Q4 revenue increased by 15%
Print version:
[PRINT] Sales Report | Q4 revenue increased by 15%

Observe como o mesmo objeto Report se comporta de maneira diferente dependendo de qual referência de interface você usa para acessá-lo. Este é o poder da implementação explícita de interface - resolver colisões de nomes enquanto fornece um comportamento apropriado ao contexto!

Folha de consulta

Quando uma classe implementa múltiplas interfaces com membros que possuem o mesmo nome, você pode usar a implementação explícita de interface para fornecer implementações separadas para cada interface.

Para implementar explicitamente um membro de interface, prefixe o nome do membro com o nome da interface e omita o modificador de acesso:

public interface IAmericanPlug
{
    void Connect();
}

public interface IEuropeanPlug
{
    void Connect();
}

public class UniversalAdapter : IAmericanPlug, IEuropeanPlug
{
    void IAmericanPlug.Connect()
    {
        Console.WriteLine("Connected to 120V");
    }
    
    void IEuropeanPlug.Connect()
    {
        Console.WriteLine("Connected to 220V");
    }
}

Membros implementados explicitamente só podem ser acessados através de uma variável do tipo da interface, não através da própria classe:

var adapter = new UniversalAdapter();
// adapter.Connect();  // Não compilará!

IAmericanPlug american = adapter;
american.Connect();  // Connected to 120V

IEuropeanPlug european = adapter;
european.Connect();  // Connected to 220V

Esta técnica é útil para:

Resolver colisões de nomes entre membros de interface
Ocultar membros de interface da API pública da classe quando eles só fazem sentido em um contexto de interface específico

Experimente você mesmo

using System;
using Reports;

class Program
{
    public static void Main(string[] args)
    {
        // Ler a entrada
        string title = Console.ReadLine();
        string content = Console.ReadLine();

        // TODO: Criar um objeto Report com o title e o content

        // TODO: Armazenar o report em uma variável IDisplayable

        // TODO: Armazenar o mesmo report em uma variável IPrintable

        // TODO: Imprimir a versão de exibição chamando Render() em IDisplayable
        Console.WriteLine("Display version:");
        // Imprimir o resultado do render aqui

        // TODO: Imprimir a versão de impressão chamando Render() em IPrintable
        Console.WriteLine("Print version:");
        // Imprimir o resultado do render aqui
    }
}