Interface C#

Neste tutorial, aprenderemos sobre a interface C# com a ajuda de exemplos.

Em C#, uma interface é semelhante a uma classe abstrata. No entanto, ao contrário das classes abstratas, todos os métodos de uma interface são totalmente abstratos (método sem corpo).

Usamos o interface palavra-chave para criar uma interface. Por exemplo,

interface IPolygon {

  // method without body
  void calculateArea();
}

Aqui,

IPolygon é o nome da interface.
Por convenção, a interface começa com I para que possamos identificá-la apenas vendo seu nome.
Não podemos usar modificadores de acesso dentro de uma interface.
Todos os membros de uma interface são públicos por padrão.
Uma interface não permite campos.

Implementando uma interface

Não podemos criar objetos de uma interface. Para usar uma interface, outras classes devem implementá-la. Igual ao C# Herança, usamos : símbolo para implementar uma interface. Por exemplo,

using System;
namespace CsharpInterface {

  interface IPolygon {
    // method without body
    void calculateArea(int l, int b);

  }

  class Rectangle : IPolygon {

    // implementation of methods inside interface
    public void calculateArea(int l, int b) {

      int area = l * b;
      Console.WriteLine("Area of Rectangle: " + area);
    }
  }

  class Program {
    static void Main (string [] args) {

      Rectangle r1 = new Rectangle();
    
      r1.calculateArea(100, 200);

    }
  }
}

Saída

Area of Rectangle: 20000

No exemplo acima, criamos uma interface chamada IPolygon . A interface contém um método calculateArea(int a, int b) sem implementação.

Aqui, o Retângulo classe implementa IPolygon . E fornece a implementação do calculateArea(int a, int b) método.

Observação :Devemos fornecer a implementação de todos os métodos de interface dentro da classe que a implementa.

Implementação de várias interfaces

Ao contrário da herança, uma classe pode implementar várias interfaces. Por exemplo,

using System;
namespace CsharpInterface {

  interface IPolygon {
    // method without body
    void calculateArea(int a, int b);

  }

  interface IColor {

    void getColor();
  }
   
  // implements two interface
  class Rectangle : IPolygon, IColor {

    // implementation of IPolygon interface
    public void calculateArea(int a, int b) {

      int area = a * b;
      Console.WriteLine("Area of Rectangle: " + area);
    }

    // implementation of IColor interface
    public void getColor() {

      Console.WriteLine("Red Rectangle");
            
    }
  }

  class Program {
    static void Main (string [] args) {

      Rectangle r1 = new Rectangle();
    
      r1.calculateArea(100, 200);
      r1.getColor();
    }
  }
}

Saída

Area of Rectangle: 20000
Red Rectangle

No exemplo acima, temos duas interfaces, IPolygon e IColor .

class Rectangle : IPolygon, IColor {
  …
}

Implementamos ambas as interfaces no Rectangle classe separada por , .

Agora, Rectangle tem que implementar o método de ambas as interfaces.

Usando a variável de referência de uma interface

Podemos usar a variável de referência de uma interface. Por exemplo,

using System;
namespace CsharpInterface {

  interface IPolygon {
    // method without body
    void calculateArea(int l, int b);

  }

  class Rectangle : IPolygon {

    // implementation of methods inside interface
    public void calculateArea(int l, int b) {

      int area = l * b;
      Console.WriteLine("Area of Rectangle: " + area);
    }
  }

  class Program {
    static void Main (string [] args) {
       
      // using reference variable of interface
      IPolygon r1 = new Rectangle();
    
      r1.calculateArea(100, 200);
    }
  }
}

Saída

Area of Rectangle: 20000

No exemplo acima, criamos uma interface chamada IPolygon . A interface contém um método calculateArea(int l, int b) sem implementação.

IPolygon r1 = new Rectangle();

Observe que usamos a variável de referência da interface IPolygon . Ele aponta para a classe Retangle que o implementa.

Embora não possamos criar objetos de uma interface, ainda podemos usar a variável de referência da interface que aponta para sua classe implementada.

Exemplo prático de interface

Vamos ver um exemplo mais prático de Interface C#.

using System;
namespace CsharpInterface {

  interface IPolygon {
    // method without body
    void calculateArea();

  }   
  // implements interface
  class Rectangle : IPolygon {

    // implementation of IPolygon interface
    public void calculateArea() {
      
      int l = 30;
      int b = 90;
      int area = l * b;
      Console.WriteLine("Area of Rectangle: " + area);
    }
  }

  class Square : IPolygon {

    // implementation of IPolygon interface
    public void calculateArea() {
      
      int l = 30;
      int area = l * l;
      Console.WriteLine("Area of Square: " + area);
    }
  }

  class Program {
    static void Main (string [] args) {

      Rectangle r1 = new Rectangle();  
      r1.calculateArea();

      Square s1 = new Square();  
      s1.calculateArea();
    }
  }
}

Saída

Area of Rectangle: 2700
Area of Square: 900

No programa acima, criamos uma interface chamada IPolygon . Tem um método abstrato calculateArea() .

Temos duas classes Quadrado e Retângulo que implementam o IPolygon interface.

A regra para calcular a área é diferente para cada polígono. Portanto, calculateArea() está incluído sem implementação.

Qualquer classe que implemente IPolygon deve fornecer uma implementação de calculateArea() . Portanto, a implementação do método na classe Rectangle é independente do método na classe Quadrado .

Vantagens da interface C#

Agora que sabemos o que são interfaces, vamos aprender por que as interfaces são usadas em C#.

Semelhante às classes abstratas, as interfaces nos ajudam a alcançar a abstração em C# .

Aqui, o método calculateArea() dentro da interface, não possui corpo. Assim, ele oculta os detalhes de implementação do método.

As interfaces fornecem especificações que uma classe (que a implementa) deve seguir.

Em nosso exemplo anterior, usamos calculateArea() como uma especificação dentro da interface IPolygon . Isso é como estabelecer uma regra de que devemos calcular a área de cada polígono.

Agora, qualquer classe que implemente o IPolygon interface deve fornecer uma implementação para o calculateArea() método.

As interfaces são usadas para obter herança múltipla em C#.

As interfaces fornecem acoplamento fraco (tendo nenhum ou menos efeito em outras partes do código quando alteramos uma parte de um código).

Em nosso exemplo anterior, se alterarmos a implementação de calculateArea() no Quadrado classe não afeta o Retângulo aula.

Classe e método selados em C# Sobrecarga do método C#

Linguagem C