Trocando mensagens (entre aplicações) usando MSMQ (com C#)

Olá pessoal. Tudo certo?

Integrar aplicações não é tarefa fácil. Há diversas alternativas. Entretanto, as mais atraentes envolvem a utilização de algum tipo de mensageria.

No “mundo Microsoft”, a alternativa mais comum é a utilização do MSMQ (Microsoft Messaging Queuing), que está na versão 5.0. Em .NET, a interface com essa tecnologia pode ocorrer tanto através de WCF quanto pela API disponível na DLL System.Messaging.

Este é apenas o primeiro de muitos posts que pretendo escrever sobre padrões de integração. Minha intenção é demonstrar todos aqueles descritos no excelente livro “Enterprise Integration Patterns” de Gregor Hohpe e Bobby Woolf.

Antes de começar

O MSMQ é forncecido como um “componente” do sistema operacional. Para utilizar este componente, antes, precisamos habilitá-lo apropriadamente.

Fazendo isso, poderemos “monitorar” (e interferir) no funcionamento do componente no “Management Console”

Pegando a idéia básica

O conceito básico do MSMQ envolve em aplicações trocando mensagens. Vejamos a explicação disponível no MSDN.

Message Queuing (MSMQ) technology enables applications running at different times to communicate across heterogeneous networks and systems that may be temporarily offline. Applications send messages to queues and read messages from queues. The following illustration shows how a queue can hold messages that are generated by multiple sending applications and read by multiple receiving applications.

A segurança e confiabilidade dessa solução a credencia como alternativa interessante para comunicação entre aplicações.

Pensando em Arquitetura

Em sua forma mais básica, a arquitetura de uma aplicação com suporte a mensageria se baseia no relacionamento de apenas três componentes:

1. Sending Application (Publisher)
2. Message Queue – fornecida completamente pelo MSMQ
3. Receiving Application (Subscriber)

Entretanto, podemos projetar soluções mais ricas. Entre as opções arquiteturais mais frequentes, encontramos:

• Múltiplos publishers;
• Múltiplos subscribers;
• Múltiplas Queues;
• Pipes e Filtros;
• Tratadores de falha (com filas de falha, inclusive);
• Roteadores;
• Tradutores (mudando o formato da mensagem);
• Adaptadores, Bridges e Bus;
• etc.

Cada uma dessas “opções” permite discussão rica que faremos com cuidado em momentos oportunos. Além disso, quase todos os padrões envolvendo Queues facilitam o desenvolvimento de soluções escaláveis.

Exemplo simples para envio de mensagens

Escrever um programa para enviar mensagens para uma Queue é algo bem simples. O exemplo que apresento aqui é uma aplicação console que envia toda digitação do usuário (após o Enter). Observe:

using System;
using System.Messaging;

namespace MessageSender
{
    class Program
    {
        const string queue_name = @".\private$\sample_queue";

        static void Main(string[] args)
        {
            Console.Title = "Sender";
            
            MessageQueue queue;
            if (MessageQueue.Exists(queue_name))
                queue = new MessageQueue(queue_name);
            else
                queue = MessageQueue.Create(queue_name);

            while (true)
                queue.Send(Console.ReadLine());
        }
    }
}

Consideremos:

• Para utilizar o suporte a Messaging do .NET (MSMQ), precisamos adicionar uma referência para System.Messaging;
• Precisamos criar (ou abrir) uma queue de trabalho. Para isso, precisamos informar a “máquina” onde ela deverá ser criada (Por agora, deixemos esse “detalhe” para uma discussão futura);
• Utilizamos o método Send para enviar mensagens. Podemos enviar (quase) qualquer objeto (precisa ser serializável) para a Queue;

Veja a execução:

No exemplo, enviei três mensagens para a Queue (que criamos). Consultando o Console Management, podemos confirmar isso. Observe:

Exemplo simples para recebimento de mensagens

Escrever programas para receber mensagens também é bastante simples. Observe:

using System;
using System.Messaging;

namespace MessageReceiver
{
    class Program
    {
        const string queue_name = @".\private$\sample_queue";
        static void Main(string[] args)
        {
            Console.Title = "Receiver";

            var queue = new MessageQueue(queue_name);
            queue.Formatter = new XmlMessageFormatter(new [] { typeof(string) });

            while (true)
                Console.WriteLine("Received: {0}", queue.Receive().Body);
        }
    }
}

Consideremos:

• Para utilizar o suporte a Messaging do .NET (MSMQ), precisamos adicionar uma referência para System.Messaging;
• Precisamos abrir uma queue de trabalho.
• O tipo do objeto no “corpo da mensagem” deverá ser informado em um Formatter que será utilizado pela infra para “recriar” objetos enviados na mensagem. No exemplo que estou apresentando, usamos string
• Utilizamos o método Receive para receber mensagens (retirando-as da Queue). Por default, esse método “interrompe” a execução até que uma mensagem esteja disponível. Há outras sobrecargas para esse método que permitem que informemos um tempo limite de espera. Há também o método Peek que não retira a mensagem da fila;

Executando esse programa, temos:

Monitorando o status da queue, percebemos que todas as mensagens foram retiradas.

Já temos um bom começo.

Era isso.