Um dos mais importantes fatores para a boa modularização de seu código, é um sistema de eventos bem definido e otimizado. O CLR expõe inúmeros eventos para cada um de seus controles, bem como classes de argumentos definidas para cada um de seus eventos.

No entanto, em algum momento, você irá se deparar com um situação onde nenhuma dessas opções lhe servirão. Aí entram os eventos personalizados. No .NET você pode criar seu próprio evento, bem como classes de argumentos e consumí-los diretamente em seu código. Como exemplo, faremos uma classe de argumento, uma classe de evento e a classe consumidora que será um aplicativo Windows Forms. Mãos ao código!

Definições:

Em nosso aplicativo Windows Forms, precisaremos validar o nome do usuário em um Textbox e apresentar uma mensagem personalizada. Para isso criaremos nossa classe de argumentos do evento; FormOKEventArgs.

public class FormEventArgs : System.EventArgs
    {
        public bool formok;
        public int formerrorcode;
        public string formerrormessage;

        public FormEventArgs(bool formOK, int formErrorCode, string formErrorMessage)
        {
            formok = formOK;
            formerrorcode = formErrorCode;
            formerrormessage = formErrorMessage;
        }
    }

[sigla]

Sua classe de argumentos personalizada deve seguir algumas regras:

• .A nomenclatura deve terminar com EventArgs. Esta é uma boa pratica citada pela Microsoft, quando trabalhamos com eventos personalizados.
• .Sua classe de argumentos deve ser derivada de System.EventAgs.
• .Para efeitos de demonstração a única tarefa desta classe é atribuir valores a campos no construtor da classe.

[/sigla]

Agora que já temos nossa classe de argumento pronta, criaremos nossa segunda classe, onde o evento será declarado.

public delegate void FormOKEventHandler(object sender, FormEventArgs e);

    public class FormOKEvent
    {

        public event FormOKEventHandler FormOK;

        public void CheckForm(string name)
        {
            if (name != "")
            {
                OnFormOK(this, new FormEventArgs(true, 500, "Logon Success. Welcome " name));
            }
            else
            {
                OnFormOK(false, new FormEventArgs(true, 504, "Logon Failure."));
            }
        }

        protected virtual void OnFormOK(object sender, FormEventArgs e)
        {
            if (FormOK != null)
            {
                FormOK(this, e);
            }
        }
    }

O primeiro passo é criar o delegate, que será responsável por definir os parâmetros que serão passados ao método que gerenciará o evento. Logo após, é feita a declaração do evento, através da palavra-chave event. E por último, o método que fará a chamada do evento.

Alguns pontos importantes a notar:

[c]

• .A declaração do Delegate é feita fora da Classe, dentro do namespace.
• .A declaração do evento, tem como tipo o delegate criado anteriormente.
• .O método OnFormOK tem como função checar se há algum cliente inscrito para receber as notificações do evento. Se não houver nenhum cliente inscrito, não há motivo para lançar o evento.
• .O método CheckForm será usado pela classe que irá consumir o evento, para lança-lo.

[/c]

Por fim, em nosso aplicativo Windows Forms, consumiremos o evento da seguinte maneira:

public partial class Form1 : Form
    {
        private FormOKEvent formokclass = new FormOKEvent();

        public Form1()
        {
            InitializeComponent();
            formokclass.FormOK = new FormOKEventHandler(formokclass_FormOK);
        }

        void formokclass_FormOK(object sender, FormEventArgs e)
        {
            MessageBox.Show(e.formerrormessage);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            formokclass.CheckForm(this.textBox1.Text);
        }
    }

É declarada uma variável do tipo da classe que retem a definição do evento. No construtor há a inscrição desta classe para receber as notificações de evento. E posteriormente a declaração da manipulação do evento.

Este foi um exemplo muito simples de como definir e consumir seus próprios eventos em seu aplicativo. Em um projeto real, os manipuladores de eventos e as classes que lhe definem seriam muito mais complexas. Mas espero que esse simples exemplo tenha lhe ajudado a compreender o mecanismo de declaração, definição e execução de um evento personalizado.

Até a proxima!