Ferramentas Online

Tutoriais Básicos C#

Tutoriais Avançados C#

Interface (Interface) do C#

C# Orientado a Objetos (OOP)

No mundo humano, um contrato entre duas ou mais pessoas obriga-as a agir conforme o contrato. Da mesma forma, uma interface inclui declarações de funcionalidades relacionadas. A entidade que implementa a interface deve fornecer a implementação das funcionalidades declaradas.

A seguir, uma declaração de interface que define algumas funcionalidades básicas de operação de arquivo.

Exemplo: interface C#

interface　IFile
{
　　　　void　ReadFile();
　　　　void WriteFile(string text);
}

Você não pode aplicar modificadores de acesso aos membros da interface. Por padrão, todos os membros são públicos. Se você usar modificadores de acesso em uma interface, o compilador C# emitirá um erro de tempo de compilação “O modificador ‘public’/private/‘protected’ não é válido para este item.” (O Visual Studio exibirá um erro imediatamente sem compilar.)

Exemplo: Interface inválida com modificador de acesso

interface　IFile
{
　　　　protected void ReadFile();　//Erro de compilação
　　　　private void WriteFile(string text);//Erro de compilação
}

As interfaces podem conter apenas declarações e não implementações. Isso resultará em um erro de tempo de compilação.

Exemplo: Implementação inválida de interface

interface　IFile
{
　　　　void　ReadFile();
　　　　void WriteFile(string text){
　　　　　　　　Console.Write(text);　　//Erro: Não é possível implementar método
　　　　}
}

Implementar interface

Uma classe ou um Struct pode implementar uma ou mais interfaces usando o dois-pontos (:) . 　

Sintaxe:

<Class ou Struct Nome> : <Nome da Interface>

Por exemplo, a classe a seguir implementou implicitamente a interface IFile.

Exemplo: Implementação de interface

interface　IFile
{
　　　　void　ReadFile();
　　　　void WriteFile(string text);
}
class FileInfo : IFile
{
　　　　public void ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Lendo Arquivo")
　　　　}
　　　　public void WriteFile(string text)
　　　　{
　　　　　　　　Console.WriteLine("Escrevendo　no　arquivo");
　　　　}
}

No exemplo acima, a classe FileInfo implementou a interface IFile. Ela define todos os membros da interface IFile usando o modificador de acesso public. A classe FileInfo também pode conter membros além dos membros da interface.

Os membros da interface devem ser implementados com o modificador public; caso contrário, o compilador fornecerá um erro de tempo de compilação.

Você pode criar um objeto da classe e atribuí-lo a uma variável do tipo de interface, conforme mostrado a seguir.

Exemplo: Implementação de interface

public　class　Program
{
　　　　public　static　void　Main()
　　　　{
　　　　　　　　IFile　file1　=　new　FileInfo();
　　　　　　　　FileInfo　file2　=　new　FileInfo();
　　　　　　　　file1.ReadFile();　
　　　　　　　　file1.WriteFile("content");　
　　　　　　　　file2.ReadFile();　
　　　　　　　　file2.WriteFile("content");　
　　　　}
}

Acima, criamos um objeto da classe FileInfo e o atribuímos a uma variável do tipo IFile e a uma variável do tipo FileInfo. Quando a implementação implícita da interface é feita, você pode usar a variável do tipo IFile e a variável do tipo FileInfo para acessar os membros de IFile.

Implementação explícita

As interfaces podem ser implementadas explicitamente usando <InterfaceName>.<MemberName>. Quando uma classe está implementando múltiplas interfaces, a implementação explícita é útil; portanto, é mais fácil de ler e elimina a confusão. Também é útil quando as interfaces têm nomes de métodos idênticos.

Não é necessário public Modificadores podem ser usados juntamente com a implementação explícita. Isso resultará em um erro de compilação no tempo de compilação.

Exemplo: Implementação explícita

interface　IFile
{
　　　　void　ReadFile();
　　　　void WriteFile(string text);
}
　　　　
class FileInfo : IFile
{
　　　　void　IFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Lendo Arquivo")
　　　　}
　　　　void IFile.WriteFile(string text)
　　　　{
　　　　　　　　Console.WriteLine("Escrevendo　no　arquivo");
　　　　}
}

Quando a implementação explícita de uma interface é feita, os membros da interface podem apenas ser acessados através de instâncias do tipo da interface.

Exemplo: Implementação explícita

interface　IFile
{
　　　　void　ReadFile();
　　　　void WriteFile(string text);
}
class FileInfo : IFile
{
　　　　void　IFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Lendo Arquivo")
　　　　}
　　　　void IFile.WriteFile(string text)
　　　　{
　　　　　　　　Console.WriteLine("Escrevendo　no　arquivo");
　　　　}
　　　　public　void　Search(string　text)
　　　　{
　　　　　　　　Console.WriteLine("Procurando　no　arquivo");
　　　　}
}
public　class　Program
{
　　　　public　static　void　Main()
　　　　{
　　　　　　　　IFile　file1　=　new　FileInfo();
　　　　　　　　FileInfo　file2　=　new　FileInfo();
　　　　　　　　file1.ReadFile();　
　　　　　　　　file1.WriteFile("content");　
　　　　　　　　//file1.Search("text　to　be　searched")//Erro de compilação　
　　　　　　　　
　　　　　　　　file2.Search("text　to　be　searched");
　　　　　　　　//file2.ReadFile();　//Erro de compilação　
　　　　　　　　//file2.WriteFile("content");　//Erro de compilação　
　　　　}
}

No exemplo acima, file1O objeto pode acessar apenas os membros IFile e file2Acesso apenas aos membros da classe FileInfo. Esta é a limitação da implementação explícita.

Implementação de várias interfaces

Um tipo de classe ou estrutura pode implementar várias interfaces. Ele deve fornecer a implementação de todos os membros de todas as interfaces.

Exemplo: implementação de várias interfaces

interface　IFile
{
　　　　void　ReadFile();
}
interface　IBinaryFile
{
　　　　void　OpenBinaryFile();
　　　　void　ReadFile();
}
class　FileInfo　:　IFile,　IBinaryFile
{
　　　　void　IFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Lendo　arquivo　de　texto");
　　　　}
　　　　void　IBinaryFile.OpenBinaryFile()
　　　　{
　　　　　　　　Console.WriteLine("Abrindo　arquivo　binário");
　　　　}
　　　　void　IBinaryFile.ReadFile()
　　　　{
　　　　　　　　Console.WriteLine("Lendo　arquivo　binário");
　　　　}
　　　　public　void　Search(string　text)
　　　　{
　　　　　　　　Console.WriteLine("Procurando　no　arquivo");
　　　　}
}
public　class　Program
{
　　　　public　static　void　Main()
　　　　{
　　　　　　　　IFile　file1　=　new　FileInfo();
　　　　　　　　IBinaryFile　file2　=　new　FileInfo();
　　　　　　　　FileInfo　file3　=　new　FileInfo();
　　　　　　　　file1.ReadFile();　
　　　　　　　　//file1.OpenBinaryFile();　//Erro de compilação　
　　　　　　　　//file1.SearchFile("text　to　be　searched");　//Erro de compilação　
　　　　　　　　
　　　　　　　　file2.OpenBinaryFile();
　　　　　　　　file2.ReadFile();
　　　　　　　　//file2.SearchFile("text　to　be　searched");　//Erro de compilação　
　　　　
　　　　　　　　file3.Search("text　to　be　searched");
　　　　　　　　//file3.ReadFile();　//Erro de compilação　
　　　　　　　　//file3.OpenBinaryFile();　//Erro de compilação　
　　　　}
}

Acima, FileInfo implementou duas interfaces, IFile e IBinaryFile explicitamente implementadas. Recomenda-se explicitar a implementação de interfaces ao implementar várias interfaces, para evitar confusão e melhorar a legibilidade.

Ponto a lembrar:

As interfaces podem conter declarações de métodos, propriedades, indexadores e eventos.
As interfaces não podem conter membros privados, protegidos ou internos. Por padrão, todos os membros são públicos.
As interfaces não podem conter campos e propriedades implementadas automaticamente.
Um classe ou estrutura pode implementar implicitamente ou explicitamente uma ou mais interfaces. Use o modificador public para implementar implicitamente a interface, e não use-o no caso de implementação explícita.
Implemente explicitamente a interface usando InterfaceName. MemberName.
Um interface pode herdar uma ou mais interfaces.

FileInfo do C#Classe (Class) do C#