C# - Eventos (revisitado)

 Neste artigo volto a falar sobre eventos mostrando como criar um evento na linguagem C#.

A abordagem da linguagem C# além de orientada a objetos também é orientada a eventos. Isto significa que enquanto atividades ocorrem, uma classe pode gerar eventos para indicar a ação que aconteceu, e passar informações relacionadas a outras classes que tenham aderido ao evento. Estes eventos podem ser utilizados para vários fins, incluindo a indicação do progresso de um processo de longa duração.

Desas forma, os eventos são usados para notificar ou sinalizar que um estado de um objeto foi alterado. Esta informação é útil para os clientes desse objeto (por exemplo, um clique do mouse ou uma tecla pressionada em um aplicativo GUI é um exemplo muito comum de eventos).

Em um cenário real, considere uma plataforma de mídia social como o Facebook. Sempre que atualizamos qualquer uma de nossas informações no Facebook, nossos amigos são notificados imediatamente. (Este é um exemplo muito comum do padrão de projeto Observer).

Então você pode assumir que quando você faz algumas mudanças em sua página do Facebook, internamente, alguns eventos são disparados para que seus amigos possam obter essas atualizações. Essas atualizações são recebidas apenas pelas pessoas que já estão na nossa lista de amigos (ou seja, as pessoas que aceitamos como nossos amigos).

No mundo da programação, dizemos que essas pessoas estão registradas em nossa lista de amigos. Se alguém não quiser obter atualizações, ele pode simplesmente cancelar o registro dessa lista de amigos. Portanto, os termos "registrar e cancelar o registro" estão associados a eventos,

Uma das principais vantagens do uso de eventos é que uma classe que publica um evento não precisa saber os detalhes dos assinantes em tempo de projeto. Como os eventos são baseadas em delegados (delegates), os assinantes só são adicionados quando o programa está sendo executado.

  1. Antes de avançarmos, devemos destacar os seguintes pontos:

    • Os eventos estão associados aos delegates. Para entender os eventos, você deve primeiro aprender delegates. Quando ocorre um evento, os delegates dado por seus clientes são invocados.
    • Na plataforma .NET, os eventos são implementados como multicaste delegates.
    • Um modelo de Publisher-Subscriber ou Editor-Assinante é seguido aqui. Um Publisher ou editor (ou emissor) publica uma notificação (ou informação) e o assinante recebe esta notificação. Mas os Subscribers ou assinantes têm a liberdade de quando começar a ouvir e quando parar de ouvir (em termos de programação, quando se registrar e quando cancelar o registro).
    • O Publisher ou editor é o tipo que contém o delegate. Os Subscribers ou Assinantes se registram usando += no delegate do editor e anulam o próprio registro usando -= nesse delegate. Então, quando aplicamos += ou -= para um evento, eles têm um significado especial.
    • Os Subscribers ou assinantes não falam um com o outro. Na verdade, eles são os alvos principais que suportam a arquitetura de eventos.
    • Os Subscribers ou assinantes não podem se comunicar entre si.
    • Podemos criar um sistema fracamente acoplado.
    • Usar o Visual Studio, facilita a nossa vida quando formos lidar com eventos.
    • A plataforma .NET fornece um delegado genérico que suporta o padrão de projeto evento padrão, da seguinte forma:

            public delegate void EventHandler<TEventArgs> (object sendersource, TEventArgs e)

    onde     TEventArgs: EventArgs;

A seguir veremos como implementar um evento simples na linguagem C#.

Implementando um evento simples

A para implementar um evento vamos definir as etapas que devemos seguir.

Etapa 1: Crie uma classe de editor ou Publisher

# 1.1. Crie um delegate. (Primeiro, escolha um nome para o seu evento, digamos TrabalhoFeito. Em seguida, crie um delegate com um nome como TrabalhoFeitoEventHandler).

# 1.2. Crie o evento (usando a palavra-chave event) com base no delegate

# 1.3. Levante o evento. (O padrão standard requer que o método deve ser marcado como virtual protegido. Além disso, o nome deve coincidir com o nome do evento e ser prefixado com On).

Etapa 2: Crie uma classe de assinante ou Subscriber

# 2.1.Escreva um método de manipulador de eventos. O nome do método manipulador de evento deve começar com On por convenção.

Agora vamos ao código...

Seguindo o roteiro definido crie um projeto do tipo Console Application e defina o código abaixo:

using System;
namespace Cshp_Eventos
{
    //Etapa1-Criar um publisher ou editor
    class Publisher
    {
        //Etapa1.1-Criar um delegate cujo nome seja
        //"nomeDoEvento"+EventHandler
        public delegate void TrabalhoFeitoEventHandler(object sender, EventArgs args);
        
        //Etapa1.2-Criar um evento baseado no delegate
        public event TrabalhoFeitoEventHandler TrabalhoFeito;
        public void ProcessaUmTrabalho()
        {
            Console.WriteLine("Publisher/Editor : Um trabalho foi concluído");
            //Etap1.3-Dispara o evento
            OnTrabalhoFeito();
        }
        
        /*O parão standard requer que o método seja definido como protected virtual. 
        * O nome também precisa coincidir com o nome do evento e será prefixado com 'On'.*/
        protected virtual void OnTrabalhoFeito()
        {
            if (TrabalhoFeito != null)
                 TrabalhoFeito(this, EventArgs.Empty);
        }
    }
    //Etapa2-Criar um subscriber ou assinante
    class Subscriber
    {
        //Tratamento do evento
        public void OnTrabalhoFeitoEventHandler(object sender, EventArgs args)
        {
            Console.WriteLine("O Subscriber/Assinante foi notificado");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("*** Demo de um evento simples ***");
            //cria instancia do Editor e do Assinante
            Publisher remetente = new Publisher();
            Subscriber receptor = new Subscriber();
            //Define o tratamento de evento
            remetente.TrabalhoFeito += receptor.OnTrabalhoFeitoEventHandler;
            //invoca o método
            remetente.ProcessaUmTrabalho();
            Console.ReadKey();
        }
    }
}

Executando o projeto iremos obter o seguinte resultado:

E estamos conversados...

Pegue o projeto completo aqui:   Cshp_Eventos.zip

(disse Jesus) "Não crês tu que eu estou no Pai, e que o Pai está em mim? As palavras que eu vos digo não as digo de mim mesmo, mas o Pai, que está em mim, é quem faz as obras."
 João 14:9

Referências:

José Carlos Macoratti