InterfacesInterfaces

Uma interface define um contrato que pode ser implementado por classes e estruturas.An interface defines a contract that can be implemented by classes and structs. Uma interface pode conter métodos, propriedades, eventos e indexadores.An interface can contain methods, properties, events, and indexers. Uma interface não fornece implementações dos membros que define — ela simplesmente especifica os membros que devem ser fornecidos por classes ou estruturas que implementam a interface.An interface does not provide implementations of the members it defines—it merely specifies the members that must be supplied by classes or structs that implement the interface.

As interfaces podem empregar a herança múltipla.Interfaces may employ multiple inheritance. No exemplo a seguir, a interface IComboBox herda de ITextBox e IListBox.In the following example, the interface IComboBox inherits from both ITextBox and IListBox.

interface IControl
{
    void Paint();
}
interface ITextBox: IControl
{
    void SetText(string text);
}
interface IListBox: IControl
{
    void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}

Classes e structs podem implementar várias interfaces.Classes and structs can implement multiple interfaces. No exemplo a seguir, a classe EditBox implementa IControl e IDataBound.In the following example, the class EditBox implements both IControl and IDataBound.

interface IDataBound
{
    void Bind(Binder b);
}
public class EditBox: IControl, IDataBound
{
    public void Paint() { }
    public void Bind(Binder b) { }
} 

Quando uma classe ou struct implementa uma interface específica, as instâncias dessa classe ou struct podem ser convertidas implicitamente para esse tipo de interface.When a class or struct implements a particular interface, instances of that class or struct can be implicitly converted to that interface type. Por exemploFor example

EditBox editBox = new EditBox();
IControl control = editBox;
IDataBound dataBound = editBox;

Em casos nos quais uma instância não é conhecida por ser estática para implementar uma interface específica, é possível usar conversões de tipo dinâmico.In cases where an instance is not statically known to implement a particular interface, dynamic type casts can be used. Por exemplo, as instruções a seguir usam conversões de tipo dinâmico para obter as implementações de interface de IControl e IDataBound do objeto.For example, the following statements use dynamic type casts to obtain an object’s IControl and IDataBound interface implementations. Como o tipo de tempo de execução real do objeto é EditBox, as conversões são bem-sucedidas.Because the run-time actual type of the object is EditBox, the casts succeed.

object obj = new EditBox();
IControl control = (IControl)obj;
IDataBound dataBound = (IDataBound)obj;

Na classe EditBox anterior, o método Paint da interface IControl e o método Bind da interface IDataBound são implementados usando membros públicos.In the previous EditBox class, the Paint method from the IControl interface and the Bind method from the IDataBound interface are implemented using public members. C# também oferece suporte explícito a implementações de membros de interface, permitindo que a classe ou struct evite tornar os membros públicos.C# also supports explicit interface member implementations, enabling the class or struct to avoid making the members public. Uma implementação de membro de interface explícita é escrita usando o nome do membro de interface totalmente qualificado.An explicit interface member implementation is written using the fully qualified interface member name. Por exemplo, a classe EditBox pode implementar os métodos IControl.Paint e IDataBound.Bind usando implementações de membros de interface explícita da seguinte maneira.For example, the EditBox class could implement the IControl.Paint and IDataBound.Bind methods using explicit interface member implementations as follows.

public class EditBox: IControl, IDataBound
{
    void IControl.Paint() { }
    void IDataBound.Bind(Binder b) { }
}

Os membros de interface explícita só podem ser acessados por meio do tipo de interface.Explicit interface members can only be accessed via the interface type. Por exemplo, a implementação de IControl.Paint fornecida pela classe EditBox anterior só pode ser chamada convertendo primeiro a referência EditBox ao tipo de interface IControl.For example, the implementation of IControl.Paint provided by the previous EditBox class can only be invoked by first converting the EditBox reference to the IControl interface type.

EditBox editBox = new EditBox();
editBox.Paint();            // Error, no such method
IControl control = editBox;
control.Paint();            // Ok