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:
IComparable<T>) oupublic 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:
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.
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:
IEnumerable.GetEnumerator() legado, a par de IEnumerable<T>.GetEnuerator(). Podes nunca usar essa interface, mas o compilador pode insistir.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.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.