Conteúdo

C#
Adicionar a Meu favorito
Terça Feira, 06 de Novembro de 2007

Como usar os Delegados (delegates) e

Eventos no C#
Tenho percebido que para muitas pessoas o uso de Delegados e Eventos não está muito
claro.

Bom então vamos a uma breve explicação sobre este assunto.

Em C# os delegados são objetos de primeira classe, totalmente suportados pela

linguagem, um delegado é um tipo de referência usado para encapsular um método
como uma assinatura e um tipo de retorno específico. Você pode encapsular
QUALQUER método usando um delegate, mas o método deve coincidir com o delegate
usado.

Criamos um delegado com a palavra-chave delegate seguida de um tipo de retorno e a

assinatura dos métodos que podem ser delegados a ela, conforme abaixo:

1. public delegate int delegateInteiro();

Está declaração define um delegado chamado delegateInteiro, que encapsulará

quaisquer método que retorne um inteiro.

Uma vez definindo o delegado, você pode encapsular um método-membro com ele,
instanciando-o e passando um método que coincida com o tipo de assinatura.

Acho que já deu para termos uma idéia de como um delegate funciona, agora vamos
falar um pouco sobre os Eventos.

Os eventos em C# são introduzidos junto com os delegados. Por convenção, os

manipuladores de eventos do .NET Framework retornam void e recebem dois
parâmetros. O primeiro parâmetro é a ‘fonte’ do evento (ou seja, o objeto que faz a
públicação). O segundo parâmetro é um objeto derivado do EventArgs. É recomendável
que seus manipuladores de eventos sigam esse padrão.

O EventArgs é a classe que serve de base para todos os dados de evento. A assinatura de
um evento é parecido com este abaixo:

1. public event delegateInteiro eventoInteiro;

Bom agora vamos criar um programa que simula uma passagem de tempo, Ao iniciar
nosso exercício, adicione o namespace System.Threading, com ele iremos simular um
intervalo de tempo e ver os dias passarem como se fosse em um passe de mágica.

A estrutura de nossa aplicação ficará assim:

Abaixo estamos criando nossa classe de eventos, para ser usado posteriormente em
nossa aplicação.

1. public class MeuEventArgs : EventArgs

2. {
3. public readonly int _dia;
4. public readonly int _mes;
5. public readonly int _ano;
6. public MeuEventArgs(int dia, int mes, int ano)
7. {
8. this._dia = dia;
9. this._mes = mes;
10. this._ano = ano;
11. }
12. }

Iremos criar uma Estrutura com DIA MÊS E ANO.

1. struct structData {
2. public int dia;
3. public int mes;
4. public int ano;
5. }

Para podermos gerar nossa passagem de tempo, vamos implementar a classe que
realmente fará isso.

1. public class PassagemDeTempo

2. {
3. // Note que estamos iniciando o mes com o valor 11 e o
ano com o valor 1900.
4. private int _dia;
5. private int _mes = 11;
6. private int _ano = 1900;
7. private structData _data = new structData();
8. // Declaramos nosso delegado para encapsular os
metodos.
9. public delegate void PassagemDeTempoHandler(object
sender, MeuEventArgs e);
10.
11. // Nosso evento, onde passaremos nosso delegado
com seu método encapsulado.
12. public event PassagemDeTempoHandler
OnPassagemDeTempo;
13.
14. // Iniciando a passagem de tempo.
15. public void IniciarPassagem() {
16. for (;;)
17. {
18. // Aqui estamos dando um intervalo de ½ seg. para
podermos ver essa assagem
19. Thread.Sleep(500);
20. // Gerando os dias,meses e anos e abastecendo
nossa estrutura
21. _data.mes = gerarMes(_mes);
22. _data.dia = gerarDias(_dia);
23. _data.ano = gerarAno(_ano);
24.
25. Sempre que passar um dia chamaremos nosso evento.
26. if (_data.dia != _dia)
27. {
28. MeuEventArgs eve = new MeuEventArgs(_data.dia,
_data.mes, _data.ano);
29.
30. if (OnPassagemDeTempo != null)
31. {
32.
33. OnPassagemDeTempo(this, eve);
34.
35. }
36. }
37. this._dia = _data.dia;
38. this._mes = _data.mes;
39. this._ano = _data.ano;
40. }
41. }
42. // os metodos abaixo são apenas tratamentos.
43. private int gerarDias(int dia){
44. if (dia >= 31) return 1;
45. return ++dia;
46. }
47. private int gerarMes(int mes){
48. if (_dia >= 31)
49. {
50. if (mes >= 12) return 1;
51. return ++mes;
52. }
53. else
54. return mes;
55. }
 56. public int gerarAno(int ano) {
57. if (_mes == 12 && _dia == 31)
58. return ++ano;
59. else
60. return ano;
61. }
62. }
63.
64. // Aqui em nossa classe MostrarPassagemDeTempo
que exibimos os dias passando.
65. public class MostrarPassagemDeTempo
66. {
67. public void Subscribers(PassagemDeTempo _tempo)
68. {
69. //Arqui estamos encapsulando a funcao que mostra
a passagem de tempo.
70. // note que estamos abastecendo um evento.
71. _tempo.OnPassagemDeTempo += new
PassagemDeTempo.PassagemDeTempoHandler(Mostrar);
72.
73. }
74. public void Mostrar(object sender,MeuEventArgs e)
75. {
76. Console.WriteLine("{0}/{1}/{2}", e._dia, e._mes,
e._ano);
77. }
78. }
79. }

Para finalizar em nosso MAIN apenas escreveremos 4 linha de código:

1. PassagemDeTempo PassTmp = new PassagemDeTempo();

2.
3. MostrarPassagemDeTempo MosPassTmp = new
MostrarPassagemDeTempo();
4.
5. MosPassTmp.Subscribers(PassTmp);
6.
7. PassTmp.IniciarPassagem();

Até o próximo artigo pessoal!

[]'s

Francke Peixoto