C# - Compreendendo delegates

Na primeira parte do artigo apresentei o conceito de delegates usando um exemplo bem simples. Vamos agora abordar um cenário mais real.

Vamos supor que você é um desenvolvedor e esta escrevendo um componente que executa uma lógica de cálculo.

Como bom desenvolvedor você deseja que este componente seja reutilizável, pois deseja distribuí-lo para mais de um cliente e cada cliente pode ter sua própria lógica de cálculo.

Neste cenário uma das formas de alcançar esse objetivo e escrever o seu componente usando delegates.

Vamos então incluir um novo projeto (File-> Add Project) do tipo Windows Forms Application, com o nome Cshp_Delegates2, na solução criada na aula anterior, e, a seguir, vamos incluir uma classe com o nome Calculus definindo o código abaixo nesta classe:

namespace CSharp_Delegates2
{
    public class Calculus
    {
        public delegate double Function(double x, double y);

        public static double Calcular(Function f, double x, double y, double z)
        {
            return f(x, y) + z;
        }
    }
}

Este é o componente que você esta criando.

Primeiro foi criado um delegate chamado 'Function' o qual pode invocar métodos que retornam um tipo double e aceitam dois parâmetros do tipo 'double'.

A seguir temos o método 'Calcular' que aceita o parâmetro do tipo 'Function', e 3 parâmetros do tipo double.

Agora observe a linha de código a seguir :

return f(x, y) + z;

Esta linha de código permite que o componente aceite, em tempo de execução, qualquer método que tenha a sua assinatura igual à do delegate.

Isso fornece um comportamento genérico ao componente e é justamente isso que você esta querendo.

Vamos a seguir fazer a implementação do código para ver o componente funcionando.

No formulário Form1.cs inclua o botão de comando (btnTesteComponente) e inclua o código abaixo neste formulário:

namespace Cshp_Delegates2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnTesteComponente_Click(object sender, EventArgs e)
        {
          Calculus.Function f = new Calculus.Function(MinhaImplementacao);

double resultado = Calculus.Calcular(f, 3, 4, 5);

MessageBox.Show(resultado.ToString());
}

        protected double MinhaImplementacao(double x, double y)
        {
            return x * y;
        }
    }
}

Esse código representa a implementação de um cliente para o seu componente.

Nele o cliente usa o componente para criar uma instância do delegate 'Function' e adicionar o seu método chamado 'MinhaImplementacao' na lista de invocação.

Note como a assinatura do método 'MinhaImplementacao' coincide com a assinatura do delegate Function. (retorna um double e aceita dois parâmetros do tipo double)

Agora definindo a seguinte linha de código : Calculus.Calcular(f, 3, 4, 5);

O cliente esta usando o poder dos delegate para definir a sua própria lógica de implementação : 'MinhaImplementacao' para passar para o componente.

Outros clientes podem usar outras implementações, como por exemplo :

  protected double MinhaImplementacao1(double x, double y)
   {
            return x + y;
   }

  protected double MinhaImplementacao2(double x, double y)
  {
            return x - y;
  }

  protected double MinhaImplementacao3(double x, double y)
  {
         return x / y;
  }

Assim, o seu componente torna-se reutilizável, e, embora esse exemplo não seja muito complexo ele mostra a vantagem em usar os delegates.

"Ora, o fim do mandamento é o amor de um coração puro, e de uma boa consciência, e de uma fé não fingida."
1 Timóteo 1-5

C# - Compreendendo delegates - II (revisitado)