Trilhas
/
C#
C#
/
Programa
/
Interfaces
In

Interfaces em C#

2 exercícios

Sobre Interfaces

interfaces são o principal meio de desacoplar os usos de uma classe da sua implementação. Esse desacoplamento dá flexibilidade para a manutenção da implementação e ajuda a viabilizar um comportamento genérico com segurança de tipos.

A sintaxe de uma interface é parecida com a de uma classe ou struct, exceto que os métodos e as propriedades aparecem apenas como assinatura, sem corpo.

public interface ILanguage
{
    string Speak();
}

public interface IItalianLanguage : ILanguage
{
    string Speak();
    string SpeakItalian();
}

public interface IScriptConverter
{
    string Version { get; set; }
    string ConvertCyrillicToLatin(string cyrillic);
}

A classe ou struct que implementa a interface precisa implementar todas as operações definidas por ela.

Normalmente, as interfaces fazem uma ou mais das coisas a seguir:

  • permitem que o código que as usa trate várias classes diferentes de forma genérica. Nesse caso, as interfaces desempenham o mesmo papel que uma classe base
  • expõem um subconjunto de funcionalidades para algum propósito específico (como IComparable<T>) ou
  • expõem a API pública de uma classe para que várias implementações possam coexistir. Um exemplo é o de um dublê de teste
public class ItalianTraveller : IItalianLanguage
{
    public string Speak()
    {
        return "Ciao mondo";
    }

    public string SpeakItalian()
    {
        return Speak();
    }
}

public class ItalianTravellerV2 : IItalianLanguage
{
    public string Speak()
    {
        return "migliorata - Ciao mondo";
    }

    public string SpeakItalian()
    {
        return Speak();
    }
}

public class FrenchTraveller : ILanguage
{
    public string Speak()
    {
        return "Ça va?";
    }
}

public class RussianTraveller : ILanguage, IScriptConverter
{
    public string Version { get; set; } = "1.0";

    public string Speak()
    {
        return "Привет мир";
    }

    public string ConvertCyrillicToLatin(string cyrillic)
    {
        throw new NotImplementedException();
    }
}

public class DocumentTranslator : IScriptConverter
{
    public string Version { get; set; } = "1.0";

    public string Translate(string russian)
    {
        throw new NotImplementedException();
    }

    public string ConvertCyrillicToLatin(string cyrillic)
    {
        throw new NotImplementedException();
    }
}

O código que usa as interfaces e classes acima pode:

  • tratar todos os falantes da mesma forma, independentemente do idioma.
  • permitir que algum subsistema que lida com conversão de escrita opere sem se preocupar com os tipos específicos com que está lidando.
  • continuar sem saber das mudanças no falante italiano, o que é conveniente se o código da classe e o código do usuário forem mantidos por equipes diferentes

As interfaces são amplamente usadas para dar suporte a testes, pois permitem criar mocks com facilidade.

Veja este artigo para saber em detalhes quais tipos de membro podem ser incluídos em uma interface.

As interfaces podem herdar de outras interfaces.

Os membros de uma interface são públicos por padrão.

As interfaces podem conter tipos aninhados, como literais const, enums, delegates, classes e structs. Aqui, as interfaces funcionam como namespaces da mesma forma que as classes e structs, e o comportamento e a sintaxe são idênticos.

Por design, o C# não dá suporte a herança múltipla, mas viabiliza um tipo de herança múltipla por meio de interfaces.

Além disso, o conceito de que o polimorfismo pode ser implementado por meio de interfaces está na base do mecanismo das interfaces.

Implementação explícita de interface

Às vezes, nomes e assinaturas de métodos podem ser compartilhados por duas interfaces diferentes. Para fornecer uma implementação distinta desses métodos, o C# oferece a implementação explícita de interfaces. Observe que, para usar uma implementação específica de uma interface, você precisa converter para essa interface a expressão que referencia o objeto. Atribuir, fazer um cast ou passar como parâmetro dá conta disso.

public interface IFoo
{
    void X();
}

public interface IBar
{
    void X();
}

public class Census : IFoo, IBar
{
    void IFoo.X()
    {
        Console.Write("This is from Foo");
    }

    void IBar.X()
    {
        Console.Write("This is from Bar");
    }
}

public class User
{
    public void Use()
    {
        IFoo foo = new Census();
        IBar bar = new Census();
        foo.X();
        // => "This is from Foo"
        bar.X();
        // => "This is from Bar"
    }
}

Há vários casos de uso:

  • Um conflito de domínios (como ilustrado acima), em que os métodos têm assinaturas idênticas.
  • Métodos com o mesmo nome, mas tipos de retorno diferentes: se você implementar suas próprias classes de coleção, pode descobrir que é necessária uma interface explícita para o IEnumerable.GetEnumerator() legado, ao lado de IEnumerable<T>.GetEnuerator(). Talvez você nunca use essa interface, mas o compilador pode exigir.
  • Métodos em que não há conflito de nomes entre as interfaces, mas é desejável que a classe que implementa use o nome para algum propósito relacionado: IFormattable tem um método ToString() que recebe um parâmetro de tipo de formato além de um parâmetro do tipo IFormatProvider. Uma classe como FormattableString, da Base Class Library (BCL), tem a interface para garantir que ela possa ser usada por rotinas que aceitam um IFormattable, mas é mais expressivo que sua versão principal de ToString(IFormatProvider) omita o parâmetro tipo de formato, já que ele não é usado na implementação e confundiria quem usa a API.

Implementação padrão

A versão 8 do C# resolve um problema incômodo com APIs. Se você adicionar métodos a uma interface para ampliar a funcionalidade para novas implementações, é preciso modificar todas as implementações existentes da interface para que elas cumpram o contrato da API, mesmo que não tenham nenhum comportamento específico de implementação. Agora o C# permite fornecer um método padrão como parte da interface (quem programa em Java vai reconhecer). Antes, quando uma mudança assim acontecia, uma versão 2 da interface passava a existir junto com a original.

Este artigo é uma excelente introdução às interfaces e aborda a implementação padrão e outras inovações de apoio, como membros static, private e virtual.

Editar via GitHub O link abre em uma nova janela ou aba

Aprenda Interfaces

A prática está bloqueada

Desbloqueie mais 1 exercício para praticar Interfaces