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.

Uma interface de nível superior, uma declarada em um namespace, mas não aninhada dentro de outro tipo, pode ser declarada public ou internal. O padrão é internal. Declarações de interface aninhadas, aquelas declaradas dentro de outro tipo, podem ser declaradas usando qualquer modificador de acesso.

Os membros da interface sem uma implementação não podem incluir um modificador de acesso. Os membros com uma implementação padrão podem incluir qualquer modificador de acesso.

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:

• Métodos
• Propriedades
• Indexadores
• Eventos

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.

É 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 herda de outra interface, um tipo que implementa a interface derivada deve implementar todos os membros nas interfaces base, bem como aqueles declarados na interface derivada, conforme mostrado no código a seguir:

public interface I1
{
    void M1();
}

public interface I2 : I1
{
    void M2();
}

public class C : I2
{
    // implements I1.M1
    public void M1() { }
    // implements I2.M2
    public void M2() { }
}

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

• Palavras-chave do C#
• Tipos de referência
• Interfaces
• Usando propriedades
• Usando indexadores