interface (Referência de C#)
Uma interface define um contrato. Qualquer class
, record
ou struct
que implemente esse contrato deve fornecer uma implementação dos membros definidos na interface. Uma interface pode definir uma implementação padrão para membros. Ela também pode definir membros static
para fornecer uma única implementação para a funcionalidade comum. A partir do C# 11, uma interface pode definir membros static abstract
ou static virtual
para declarar que um tipo de implementação deve fornecer os membros declarados. Normalmente, os métodos static virtual
declaram que uma implementação deve definir um conjunto de operadores sobrecarregados.
No exemplo a seguir, a classe ImplementationClass
deve implementar um método chamado SampleMethod
que não tem parâmetros e retorna void
.
Para obter mais informações e exemplos, consulte Interfaces.
Exemplo de interface
interface ISampleInterface
{
void SampleMethod();
}
class ImplementationClass : ISampleInterface
{
// Explicit interface member implementation:
void ISampleInterface.SampleMethod()
{
// Method implementation.
}
static void Main()
{
// Declare an interface instance.
ISampleInterface obj = new ImplementationClass();
// Call the member.
obj.SampleMethod();
}
}
Uma interface pode ser membro de um namespace ou de uma classe. Uma declaração de interface pode conter declarações (assinaturas sem nenhuma implementação) dos seguintes membros:
Membros da interface padrão
Normalmente, essas declarações de membro anteriores não contêm um corpo. Um membro da interface pode declarar um corpo. Os corpos de membro em uma interface representam a implementação padrão. Membros com corpos permitem que a interface forneça uma implementação "padrão" para classes e structs que não fornecem uma implementação de substituição. Uma interface pode incluir:
- Constantes
- Operadores
- Construtor estático.
- Tipos aninhados
- Campos estáticos, métodos, propriedades, indexadores e eventos
- Declarações de membro usando a sintaxe de implementação explícita da interface.
- Modificadores de acesso explícitos (o acesso padrão é
public
).
Membros estáticos abstratos e virtuais
A partir do C# 11, uma interface pode declarar membros static abstract
e static virtual
para todos os tipos de membro, exceto campos. As interfaces podem declarar que a implementação de tipos deve definir operadores ou outros membros estáticos. Esse recurso permite que algoritmos genéricos especifiquem comportamento semelhante a número. Você pode ver exemplos nos tipos numéricos no runtime do .NET, como System.Numerics.INumber<TSelf>. Essas interfaces definem operadores matemáticos comuns implementados por muitos tipos numéricos. O compilador deve resolver chamadas para métodos static virtual
e static abstract
no tempo de compilação. Os métodos static virtual
estatic abstract
declarados em interfaces não têm um mecanismo de expedição de runtime análogo a métodos virtual
ou abstract
declarados em classes. Em vez disso, o compilador usa informações de tipo disponíveis no tempo de compilação. Portanto, os métodos static virtual
são declarados quase exclusivamente em interfaces genéricas. Além disso, a maioria das interfaces que declaram os métodos static virtual
ou static abstract
declaram que um dos parâmetros de tipo deve implementar a interface declarada. Por exemplo, a interface INumber<T>
declara que T
deve implementar INumber<T>
. O compilador usa o argumento de tipo para resolver chamadas aos métodos e operadores declarados na declaração de interface. Por exemplo, o tipo int
implementa INumber<int>
. Quando o parâmetro de tipo T
denota o argumento de tipo int
, os membros static
declarados em int
são invocados. Como alternativa, quando double
é o argumento de tipo, são invocados os membros static
declarados no tipo double
.
Importante
A expedição de método para métodos static abstract
e static virtual
declarados em interfaces é resolvida usando o tipo de tempo de compilação de uma expressão. Se o tipo de runtime de uma expressão for derivado de um tipo de tempo de compilação diferente, os métodos estáticos no tipo base (tempo de compilação) serão chamados.
É possível experimentar esse recurso trabalhando com o tutorial sobre membros abstratos estáticos em interfaces.
Herança de interface
As interfaces podem não conter o estado da instância. Embora os campos estáticos agora sejam permitidos, os campos de instância não são permitidos em interfaces. Não há suporte para propriedades automáticas de instância em interfaces, pois declarariam implicitamente um campo oculto. Essa regra tem um efeito sutil nas declarações de propriedade. Em uma declaração de interface, o código a seguir não declara uma propriedade implementada automaticamente como o faria em um class
ou struct
. Em vez disso, ele declara uma propriedade que não tem uma implementação padrão, mas que deve ser implementada em qualquer tipo que implemente a interface:
public interface INamed
{
public string Name {get; set;}
}
Uma interface pode herdar de uma ou mais interfaces base. Quando uma interface substitui um método implementado em uma interface base, ela deve usar a sintaxe de implementação de interface explícita.
Quando uma lista de tipos base contém uma classe base e interfaces, a classe base deve vir em primeiro na lista.
Uma classe que implementa uma interface pode implementar membros dessa interface explicitamente. Um membro implementado explicitamente não pode ser acessado por meio de uma instância da classe, mas apenas por meio de uma instância da interface. Além disso, os membros da interface padrão só podem ser acessados por meio de uma instância da interface.
Para obter mais informações sobre a implementação explícita, consulte Implementação de interface explícita.
Exemplo de implementação de interface
O exemplo a seguir demonstra a implementação da interface. Neste exemplo, a interface contém a declaração de propriedade e a classe contém a implementação. Qualquer instância de uma classe que implementa IPoint
tem propriedades de inteiro x
e y
.
interface IPoint
{
// Property signatures:
int X { get; set; }
int Y { get; set; }
double Distance { get; }
}
class Point : IPoint
{
// Constructor:
public Point(int x, int y)
{
X = x;
Y = y;
}
// Property implementation:
public int X { get; set; }
public int Y { get; set; }
// Property implementation
public double Distance =>
Math.Sqrt(X * X + Y * Y);
}
class MainClass
{
static void PrintPoint(IPoint p)
{
Console.WriteLine("x={0}, y={1}", p.X, p.Y);
}
static void Main()
{
IPoint p = new Point(2, 3);
Console.Write("My Point: ");
PrintPoint(p);
}
}
// Output: My Point: x=2, y=3
Especificação da linguagem C#
Para obter mais informações, confira a seção Interfaces da Especificação da linguagem C#, a especificação do recurso para Membros da interface C# 8 – padrão e a especificação de recursos para C# 11 – membros abstratos estáticos em interfaces
Confira também
Comentários
https://aka.ms/ContentUserFeedback.
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulteEnviar e exibir comentários de