Implementando um EventBroker (Simples)

Olá pessoal, como estamos?

Minha proposta, para começar bem a semana, é escrever um EventBroker de propósito geral.

Quando usar um EvenBroker?

Um EventBroker atua como um centralizador para objetos que precisam disparar ou escutar eventos.

Em contraste com a prática convencional, um EventBroker permite a existência de componentes “escutando” eventos de outros sem que exista uma referência direta.

Há sempre um acordo implícito quanto a uma chave e assinatura de método (formato da mensagem). Entretanto, não há restrição nem quanto a quem publica, tão pouco quanto com quem assina um evento.

Implementando um EventBroker simples

Um EventBroker funciona como um simples intermediário para qualquer número de eventos de qualquer objeto para qualquer objeto.

Observe uma implementação extremamente simples:

public sealed class EventBroker
{
    readonly Dictionary> Subscriptions =
        new Dictionary>();

    public void Register(
        string eventId,
        Delegate method
        )
    {
        List delegates = null;
        if (!Subscriptions.TryGetValue(eventId, out delegates))
        {
            delegates = new List();
            Subscriptions.Add(eventId, delegates);
        }

        delegates.Add(method);
    }

    public void UnRegister(
        string eventId,
        Delegate method
        )
    {
        List delegates = null;
        if (!Subscriptions.TryGetValue(eventId, out delegates))
            return;

        delegates.Remove(method);
        if (delegates.Count == 0)
            Subscriptions.Remove(eventId);
    }

    public void RaiseEvent(
        string eventId,
        params object[] args
            )
    {
        List delegates = null;
        if (!Subscriptions.TryGetValue(eventId, out delegates))
            return;

        foreach (var @delegate in delegates)
            if (@delegate.Method != null && @delegate.Target != null)
                @delegate.DynamicInvoke(args);

    }
}

Como pode ver, há três métodos simples. Um para registrar, outro para cancelar o registro e, por fim, um para disparar um evento.

Como não planejo “especializar” esse código, resolvi deixar o classe sealed. Considero isso uma boa prática.

Utilização (simples) do EventBroker

A utilização é muito simples. No lugar de disparar os eventos normalmente, evocamos os métodos apropriados do EventBroker. Observe:

class Program
{
    static void Main(string[] args)
    {
        new Program().Run();
        Console.ReadLine();
    }

    public void Run()
    {
        EventBroker broker = new EventBroker();
        broker.Register("event", (Action)SayHello);
        broker.Register("event", (Action)SayGoodbye);
        broker.RaiseEvent("event", "Elemar");
    }

    public void SayHello(string name)
    {
        Console.WriteLine("Hello {0}", name);
    }

    public void SayGoodbye(string name)
    {
        Console.WriteLine("Goodbye {0}", name);
    }
}

Sugestões de uso para o EventBroker

Para ser efetivo, podemos considerar a possibilidade de criar uma instância e a compartilhar em todo o sistema. Essa instância poderia ser recuperada através de um Container ou por um provedor central de serviços.

A beleza desse mecanismo é que ele não especifica quem são os publishers. Dessa forma, sempre que um determinado tipo de “mensagem” (evento) precisar ser publicada haverá garantias de que todos os “interessados” (subscribers) serão apropriadamente acionados.

Obviamente, o código apresentado aqui é muito simples e pode contar com aprimoramentos. Entretanto, acho que é suficiente para fomentar algumas idéias.

Sem mais,

Por hoje, era isso