C#  - Apresentando o delegate EventHandler


 Neste artigo vou apresentar os conceitos relacionados ao delegate EventHandler usando a linguagem C#..
 
 O delegate EventHandler

Você sabe o que faz o delegate EventHandler ?

Ele representa um método que vai manipular um evento que não possui dados.

Você sabe o que faz o delegate EventHandler<T> ?

Ele representa um método que vai manipular um evento que possui dados.

Dessa forma o delegate EventHandler é um delegate predefinido que representa especificamente um método manipulador de eventos para um evento que não gera dados. Se o evento gerar dados, você deve usar o delegate genérico EventHandler <TEventArgs>.

Acha pouco !!!!

O modelo de evento no .NET Framework é baseado em ter um delegate do evento que conecta um evento com seu manipulador. Para disparar um evento, são necessários dois elementos:

- Um delegate que identifica o método que proporciona a resposta ao evento;
- Opcionalmente, uma classe que contém os dados do evento, se o evento fornecer dados;


O delegate é um tipo que define uma assinatura, isto é, o tipo de valor de retorno e uma lista de parâmetros de tipos para um método. Você pode usar o tipo delegate para declarar uma variável que pode se referir a qualquer método com a mesma assinatura que o delegate.

Para associar o evento com o método que manipulará o evento, adicione uma instância do delegate ao evento. O manipulador de eventos é chamado sempre que o evento ocorrer, a menos que você remova o delegate.

Como um evento pode ter vários manipuladores, usando a sintaxe do manipulador de eventos (EventHandler), podemos criar um sistema de notificação.  Atribuímos métodos adicionais sem alterar outras partes do código e com isso temos que nosso código fica fácil de manter.

Vamos ver como isso funciona...

Usando o delegate EventHandler

Vamos criar uma aplicação Console Application usando o Visual Studio 2015 Community com o nome UsandoEventHandler

Se a implementação da interface foi feita corretamente o evento será disparado sempre que o valor da propriedade do objeto for alterada.

Para testar vamos incluir o código abaixo no arquivo Program.cs do projeto:

using System;
namespace UsandoEventHandler
{
    // Definimos um EventHandler usando a palavra chave delegate 
    //  para especificar o tipo do EventHandler.
    public delegate void EventHandler();
    class Program
    {
        // A palavra chave event que cria um evento. 
        // Ela é usada para criar uma instância de um evento 
        // que pode armazenar métodos na sua lista de invocação.
        public static event EventHandler OnCalcular;
        static void Main(string[] args)
        {
            //Adiciona manipuladores de eventos ao evento OnCalcular
            OnCalcular += new EventHandler(Somar);
            OnCalcular += new EventHandler(Subtrair);
            OnCalcular += new EventHandler(Multiplicar);
            OnCalcular += new EventHandler(Multiplicar);
            // Invoca o evento
            OnCalcular.Invoke();
            Console.ReadLine();
        }
        static void Somar()
        {
            Console.WriteLine(String.Format(" 5 + 5 = {0}", 5 + 5));
        }
        static void Subtrair()
        {
            Console.WriteLine(String.Format(" 5 - 5 = {0}", 5 - 5));
        }
        static void Multiplicar()
        {
            Console.WriteLine(String.Format(" 5 x 5 = {0}", 5 * 5));
        }
    }
}

No código o evento OnCalcular possui 4 instâncias de métodos adicionados na sua lista de invocação usando o operador +=. (Este operador não tem nada a ver com o operador aritmético de adição)

Na lista de invocação do evento OnCalcular, adicionamos 4 eventos:  Somar, Subtrair e duas instâncias de Multiplicar.

Quando o método Invoke for chamado, cada um destas instâncias de métodos serão chamadas e o resultado será exibido no console.

Assim vemos que usando eventos podemos adicionar métodos que serão disparados em um evento externo.

Veja que quando chamamos o método Invoke para o evento, não precisamos conhecer todos os manipuladores que foram adicionados. Isso reduz a complexidade e facilita a manutenção do código.

Um evento é um membro que permite que um objeto ou classe forneça notificações.

Dessa forma podemos usar eventos para realizar notificações de forma que outras partes do programa podem tratar esses eventos com seus manipuladores.

Executando o projeto iremos obter o seguinte resultado:



Pegue o projeto aqui :  UsandoEventHandler.zip

Porque a palavra da cruz é loucura para os que perecem; mas para nós, que somos salvos, é o poder de Deus.
Porque está escrito: Destruirei a sabedoria dos sábios, E aniquilarei a inteligência dos inteligentes.

1 Coríntios 1:18,19

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Quer aprender a criar aplicações Web Dinâmicas usando a ASP .NET MVC 5 ?

 

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

 

Referências:


José Carlos Macoratti