Interfaces e delegates em C#

Uma interface, no paradigma da orientação a objetos, é um tipo de classe que contém apenas as assinaturas de métodos, propriedades, eventos e indexadores. Neste post veja interfaces e delegates em C#.

A implementação dos membros é feita por uma classe concreta ou struct que implementa a interface.

Na linguagem C# a sintaxe usada para indicar a utilização de uma interface é colocar dois pontos após o nome da classe concreta que vai implementar a interface seguido do nome da interface. Veja:

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();
    }
}

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