Percursos
/
C#
C#
/
Programa
/
Interfaces
In

Interfaces em C#

2 exercícios

Sobre Interfaces

interfaces são o principal meio de desacoplamento entre a utilização de uma classe e a sua implementação. Este desacoplamento oferece flexibilidade para a manutenção da implementação e ajuda a suportar comportamento genérico seguro em termos de tipos.

A sintaxe de uma interface é semelhante à de uma classe ou estrutura, exceto que os métodos e as propriedades aparecem apenas como assinatura e não é fornecido qualquer 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 estrutura que implementa a interface tem de implementar todas as operações definidas pela interface.

As interfaces fazem normalmente uma ou mais das seguintes coisas:

  • permitir que várias classes diferentes sejam tratadas genericamente pelo código que as utiliza. Neste caso, as interfaces desempenham o mesmo papel que uma classe base
  • expor um subconjunto de funcionalidades para um propósito específico (como IComparable<T>) ou
  • expor a API pública de uma classe para que várias implementações possam coexistir. Um exemplo é o de um duplo 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 utiliza as interfaces e classes acima pode:

  • tratar todos os oradores da mesma forma, independentemente da linguagem.
  • permitir que algum subsistema que trate da conversão de escrita funcione sem se preocupar com os tipos específicos com que está a lidar.
  • manter-se alheio às alterações ao orador italiano, o que é conveniente se o código da classe e o código do utilizador forem mantidos por equipas diferentes

As interfaces são amplamente utilizadas para apoiar os testes, pois permitem uma fácil simulação.

Vê este artigo para obteres detalhes sobre que tipos de membros podem ser incluídos numa interface.

As interfaces podem herdar de outras interfaces.

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

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

Por conceção, o C# não suporta herança múltipla, mas facilita um tipo de herança múltipla através de interfaces.

Além disso, o mecanismo das interfaces assenta no conceito de que o polimorfismo pode ser implementado através de interfaces.

Implementação explícita de interfaces

Por vezes, nomes e assinaturas de métodos podem ser partilhados entre duas interfaces diferentes. Para fornecer uma implementação distinta destes métodos, o C# disponibiliza a implementação explícita de interfaces. Repara que, para usar uma implementação específica de uma interface, tens de converter a expressão que contém a referência ao objeto para essa interface. A atribuição, a conversão de tipo ou a passagem como parâmetro conseguem isso.

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"
    }
}

Existem 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 implementares as tuas próprias classes de coleção, podes constatar que é necessária uma interface explícita para o IEnumerable.GetEnumerator() legado, a par de IEnumerable<T>.GetEnuerator(). Podes nunca usar essa interface, mas o compilador pode insistir.
  • Métodos em que não há conflito de nomes entre 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 tipo de formato, bem como um parâmetro do tipo IFormatProvider. Uma classe como FormattableString da Biblioteca de Classes Base (BCL) tem a interface para garantir que pode ser usada por rotinas que recebem um IFormattable, mas é mais expressivo que a sua versão principal de ToString(IFormatProvider) omita o parâmetro tipo de formato, uma vez que não é usado na implementação e confundiria os utilizadores da API.

Implementação predefinida

A versão 8 do C# resolve um problema persistente com as APIs. Se adicionares métodos a uma interface para melhorar a funcionalidade para novas implementações, é necessário modificar todas as implementações existentes da interface para que cumpram o contrato da API, mesmo que não tenham comportamento específico de implementação. O C# permite agora que um método predefinido seja fornecido como parte da interface (os programadores de Java estão familiarizados com isto). Anteriormente, quando ocorria uma alteração deste tipo, existia uma versão 2 da interface a par da original.

Este artigo é uma excelente introdução às interfaces e foca-se na implementação predefinida e noutras inovações de suporte, como membros static, private e virtual.

Editar via GitHub A ligação abre numa nova janela ou separador

Aprende Interfaces

A prática está bloqueada

Desbloqueia mais 1 exercício para praticares Interfaces