Interface de extensão C#

Resumo : neste tutorial, você aprenderá como definir uma interface que estende uma única interface ou múltiplas interfaces.

Estendendo uma interface

C# permite que uma interface estenda uma ou mais interfaces. O exemplo a seguir ilustra como definir uma interface que estende outra interface:

Primeiro, defina a IUndoableinterface que possui um método Undo():

interface IUndoable
{
    void Undo();
}Linguagem de código:  C#  ( cs )

Segundo, defina a IRedoableinterface que estende a IUndoableinterface:

interface IRedoable : IUndoable
{
    void Redo();
}Linguagem de código:  C#  ( cs )

Neste exemplo, a IRedoableinterface herda todos os membros da IUndoableinterface. Em outras palavras, uma classe que implementa a IRedoableinterface também deve fornecer implementações para Redo()o método na IRedoableinterface e para o Undo()método da IUndoableinterface.

Terceiro, defina a Inputclasse que implementa a IRedoableinterface:

class Input : IRedoable
{
    public void Redo()
    {
        Console.WriteLine("Redo");
    }

    public void Undo()
    {
        Console.WriteLine("Undo");
    }
}Linguagem de código:  C#  ( cs )

Por fim, crie uma instância da Inputclasse e chame os métodos Undo()e :Redo()

var input = new Input();
input.Undo();
input.Redo();Linguagem de código:  C#  ( cs )

Saída:

Undo
RedoLinguagem de código:  C#  ( cs )

Estendendo múltiplas interfaces

Para definir uma interface que estende duas ou mais interfaces, use a seguinte sintaxe:

interface IMyInterface: IMyInterface1, IMyInterface2, IMyInterface3
{
}Linguagem de código:  C#  ( cs )

Nesse caso, MyInterfaceherda todos os membros de todas as interfaces, incluindo IMyInterface1, IMyInterface2e IMyInterface3.

Em outras palavras, uma classe que implementa as MyInterfacenecessidades fornece implementações para todos os membros dessas interfaces.

O exemplo a seguir ilustra como definir uma interface que estende várias interfaces.

Primeiro, defina duas interfaces IStoree IRetrieve:

interface IStore
{
    void Store(string data);
}

interface IRetrieve
{
    string? Retrieve();
}Linguagem de código:  C#  ( cs )

Segundo, defina uma interface IMessageque estenda as interfaces IStoree :IRetrieve

interface IMessage : IStore, IRetrieve
{
    void Delete();
}Linguagem de código:  C#  ( cs )

A IMessageinterface possui seu próprio método Delete(). Ele também herda métodos das interfaces IStoree IRetrieve. Isso significa que uma classe que implementa a IMessageinterface precisa implementar todos os três métodos.

Terceiro, defina a Messageclasse que implementa a IMessageinterface:

class Message : IMessage
{
    private string? data = null;

    public void Delete()
    {
        data = null;
    }

    public string? Retrieve()
    {
        return data;
    }

    public void Store(string message)
    {
        data = message;
    }
}Linguagem de código:  C#  ( cs )

Por fim, crie uma instância da Messageclasse e chame seus métodos:

// Program.cs

Message message = new();

message.Store("Hello");
Console.WriteLine(message.Retrieve());
message.Delete();Linguagem de código:  C#  ( cs )

Saída:

HelloLinguagem de código:  C#  ( cs )

Resumo

• Uma interface pode estender uma ou mais interfaces.
• Uma classe que implementa uma interface precisa fornecer implementações para todos os membros da interface e para os membros que a interface herda de outras interfaces.