Interfaces e delegates em C#

No desenvolvimento em C#, interfaces e delegates são ferramentas poderosas que nos permitem escrever código flexível, reutilizável e modular. Embora ambos sejam conceitos fundamentais da linguagem, eles são usados para finalidades bem diferentes. Neste post, vamos explorar o que são Interfaces e delegates em C# e como utilizar cada um.

O que são Interfaces?

Uma interface em C# define um contrato que uma classe deve seguir. Ela especifica quais métodos e propriedades uma classe deve implementar, sem dizer como esses métodos devem ser implementados. Isso garante que diferentes classes possam ser tratadas de forma uniforme, desde que implementem a mesma interface.

Veja um exemplo de uma interface simples:

public interface IOperacao
{
    void Executar();
}

Agora, qualquer classe que implementar IOperacao deve fornecer uma implementação do método Executar:

public class Soma : IOperacao
{
    public void Executar()
    {
        Console.WriteLine("Executando soma.");
    }
}

public class Subtracao : IOperacao
{
    public void Executar()
    {
        Console.WriteLine("Executando subtração.");
    }
}

Com isso, podemos escrever código que trata essas classes de forma uniforme:

IOperacao operacao = new Soma();
operacao.Executar(); // Saída: Executando soma.

Quando usar Interfaces?

• Quando você quer garantir que diferentes classes implementem os mesmos métodos;
  
  
• Ao usar a programação orientada a interfaces, facilitando a criação de código flexível e escalável;
  
  
• Quando você precisa desacoplar as classes do seu sistema, favorecendo a extensibilidade.

O que são Delegates?

Os delegates são uma forma de definir métodos anônimos ou referenciar métodos para passar como parâmetros. Eles funcionam como ponteiros para métodos e são usados para passar comportamento como parâmetro, permitindo a criação de funções dinâmicas em tempo de execução.

Veja um exemplo de como declarar e usar um delegate:

public delegate void ProcessarOperacao(int x, int y);

public class Operacoes
{
    public void Somar(int x, int y)
    {
        Console.WriteLine(x + y);
    }

    public void Subtrair(int x, int y)
    {
        Console.WriteLine(x - y);
    }
}

Agora podemos usar o delegate para apontar para diferentes métodos:

Operacoes operacoes = new Operacoes();
ProcessarOperacao processar = new ProcessarOperacao(operacoes.Somar);
processar(10, 5); // Saída: 15

processar = new ProcessarOperacao(operacoes.Subtrair);
processar(10, 5); // Saída: 5

Quando usar Delegates?

• Quando você precisa passar métodos como parâmetros, tornando o código mais flexível;
  
  
• Para trabalhar com eventos e callbacks;
  
  
• Em cenários que envolvem funções de ordem superior, onde um método pode ser passado para outro método.

Principais diferenças

• Interface define um contrato de implementação de métodos, enquanto delegates apontam diretamente para um método;
  
  
• Interfaces são usadas para abstrair comportamento comum em várias classes, já delegates são usados para executar ou referenciar métodos dinamicamente.

Outro exemplo prático

public interface ClassInterf  { //declaração da interface
    
   int adic(int n1, int n2);  //métodos não implementados da interface
   float div(float n3, float n4);
}
    
//a classe Principal implementa a interface ClassInterf
class Principal: ClassInterf {
    
   public int adic(int n1, int n2) { //métodos implementados
      
        return n1 + n2;
    }

   public float div(float n3, float n4) {
      
        return n3 / n4;
   }    	 
 }

	
/* Delegates é um objeto que pode referenciar um método, isto é, pode conter o endereço de memória do entry point deste método e assim chamá-lo. */

/* Delegates é um tipo de referência que pode ser usado para encapsular um nomeada ou um método anônimo. Delegates são semelhantes aos  ponteiros de função em C++; entretanto, delegates são fortemente tipados e seguros: */	

delegate int Operac(int n1, int n2);  //declaração da delegate

class Principal {
	
   static int soma(int n1, int n2) {
		
      return n1 + n2;
   }
    
   public static void main() {
		
      Console.Clear();

      //cria um delegate - atribui a referência (endereço) ao método soma()
      Operac ref = new Operac(soma);

      //Operac ref1 = soma; // também pode ser assim
      int resultado;
      resultado = ref(5, 7);  //o delegate chama o método soma()
      Console.WriteLine("Soma: " + resultado);
      Console.ReadLine();
    }
}

Tanto interfaces quanto delegates são essenciais para desenvolver aplicações robustas e escaláveis em C#.

Entender suas diferenças e quando aplicá-los ajudará você a escrever código mais limpo e eficiente. As interfaces ajudam na organização e estruturação de um projeto orientado a objetos, enquanto delegates são excelentes para criar comportamentos dinâmicos e eventos.

Dúvidas ou sugestões? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: delegate c# | interface c#