Delegates e eventos no C# 2.0 - Parte 1

Delegate é uma classe especial que funciona como ponteiros para funções, quando criamos uma instância dele, passamos ao construtor o nome da função que desejamos referenciar. Podemos utilizar delegates associados ou não a eventos no .NET.

por Rodolfo Paoni

Delegate é uma classe especial que funciona como ponteiros para funções, quando criamos uma instância dele, passamos ao construtor o nome da função que desejamos referenciar. Podemos utilizar delegates associados ou não a eventos no .NET.

Exemplo de delegate sendo utilizado em eventos:

delegate int Operacao(int a, int b);

public static int Soma(int a, int b)
{
return (a + b) * 3;
}

public static void Main(string[] args)
{
// Versão 1.1 do .NET Framework - Métodos declarados explicitamente
Operacao met = new Operacao(Soma);
Console.WriteLine(met(2, 4));
}

Esta é a forma como utilizávamos (e ainda utilizamos até hoje) no .NET 1.1. Com a evolução da linguagem C# e do Framerowk .NET passamos a ter o conceito de métodos anônimos (Inline) como neste exemplo:

//Versão 2.0 do .NET Framework - Métodos anônimos - Inline
Operacao op = new Operacao(delegate(int a, int b)
{
return (a + b) * 3;
});
Console.WriteLine(op(2, 4));

Mas onde está o método? O método é criado de uma maneira interna ao próprio delegate. Isto significa que ele só está disponível neste contexto. A vantagem é de não ter que criar um método a parte, se o mesmo for utilizado apenas 1 vez.

Trabalhando com eventos

Um delegate pode ter vários eventos associados. Os eventos são do tipo do delegate. Um exemplo clássico seria o evento de click de um botão. Um botão poderia ter um delegate e vários eventos associados, sendo um deles, o evento de click.

Exemplo 1:

public class Estoque
{
// Delegate
public delegate void MudancaValorHandler();

//Evento do tipo do delegate, apontando para um método com a mesma assinatura
public static event MudancaValorHandler MudancaValorEventHandler = new MudancaValorHandler(MudancaValor);

public void RealizarOperacao()
{
MudancaValorEventHandler();
}

public static void MudancaValor()
{
Console.WriteLine("Valor alterado");
}
}

class Program
{
static void Main(string[] args)
{
Estoque e = new Estoque();
e.RealizarOperacao();

Console.ReadKey();
}
}

Exemplo 2:

class Player
{
public delegate void PlayerTocando();
public delegate void PlayerParado();

public event PlayerTocando Tocando;
public event PlayerParado Parado;

//Dispara o evento "Tocando" quando chamado

public void Tocar()
{
Tocando();
}
// Dispara o evento "Parado" quando chamado
public void Parar()
{
Parado();
}
}

// Aqui temos um Form com apenas 2 botões - Tocar e Parar
public partial class Form1 : Form
{
Player Player1;

public Form1()
{
InitializeComponent();
Player1 = new Player();
}

private void Form1_Load(object sender, EventArgs e)
{
// Evento recebe uma nova instância do delegate do seu tipo e aponta
// para o método corresponde que será chamado quando disparado
Player1.Tocando += new Player.PlayerTocando(Player1_Tocando);
Player1.Parado += new Player.PlayerParado(Player1_Parado);
}

void Player1_Parado()
{
MessageBox.Show("Musica está parada");
btnParar.Visible = false;
btnTocar.Visible = true;
}

void Player1_Tocando()
{
MessageBox.Show("Musica está tocando");
btnTocar.Visible = false;
btnParar.Visible = true;
}

private void btnTocar_Click(object sender, EventArgs e)
{
// Chama o método que disparará o evento associado
Player1.Tocar();
}

private void btnParar_Click(object sender, EventArgs e)
{
// Chama o método que disparará o evento associado
Player1.Parar();
}
}

Por enquanto é só. Divirta-se com seus eventos e delegates.
Até a próxima!