asd6

6. Лекция: Microsoft Message Queuing (MSMQ) – промежуточная среда обмена сообщениями
5.1. Служба обмена сообщениями MSMQ
В настоящий момент существует несколько основных разработок в области промежуточного программного
обеспечения для работы с очередями сообщений. Наиболее известными разработками являются такие системы
очередей сообщений, как MSMQ, Sun Java System Message Queue, IBM MQSeries, Oracle Advanced Queing.
Промежуточная среда MSMQ – разработка Microsoft для асинхронной передачи сообщений внутри локальной сети,
впервые появившаяся в составе операционной системы Windows NT. В настоящее время последней является версия
MSMQ 3.0, включенная в Windows XP PE и 2003 Server, достаточно актуальна так же версия 2.0, включенная в состав
операционной системы Windows 2000.
Служба MSMQ позволяет произвольному набору приложений добавлять сообщения в некоторую очередь, и
произвольному же набору – читать сообщения из очереди. Приложению, использующему MSMQ, доступны
следующие основные операции:

добавить сообщение в очередь;

извлечь первое сообщение из очереди;

установить обработчик, вызываемый при появлении сообщения.
Структура сообщения определяется приложением, и может быть произвольной, с ограничением на размер одного
сообщения (2Мб для MSMQ 2.0). Далее будет рассмотрено использование MSMQ 2.0/3.0 при разработке приложений
с использованием .NET Framework.
При отправке сообщения с использованием MSMQ посылающему приложению необходимо указать имя
компьютера и очереди, в которую его необходимо доставить. После вызова приложением функции отправки
сообщение сохраняется в локальной исходящей очереди. Затем MSMQ определяет имя компьютера и очереди, куда
необходимо передать сообщение. Возможны следующие случаи:

сообщение доставляется сразу в указанную отправителем очередь (прямая доставка);

сообщение посылается в некоторую промежуточную очередь, определяемую маршрутизатором службы
сообщений;

MSMQ определяет, что сообщение требуется разослать в несколько очередей (возможность поддерживается
начиная с MSMQ 3.0).
Рис. 5.1. Пересылка сообщения в промежуточной среде MSMQ
После определения имени компьютера с очередью назначения, MSMQ проверяет доступность компьютера
(пакетом UDP) и в случае ответа сразу пытается отправить ему сообщение, повторяя попытки с интервалом по
умолчанию 5 секунд. Если сообщение не удается отправить, то обычно каждые 5 минут служба сообщений пытается
найти новый пункт назначения сообщения, используя маршрутизацию MSMQ. Процесс пересылки сообщения между
компьютерами повторяется, пока оно не достигнет очереди назначения. С момента поступления сообщения в
указанную при отправке очередь любое использующее MSMQ приложение с необходимыми правами доступа может
прочитать это сообщение (рис. 5.1).
Таким образом, MSMQ поддерживает асинхронную передачу сообщений, при которой участвующие в обмене
компоненты распределенной системы не обязательно должны функционировать в один и тот же момент времени.
Благодаря службе маршрутизации сообщений возможно создание моста между MSMQ и аналогичной технологией
IBM – IBM Websphere MQ (ранее MQSeries). Websphere MQ может использоваться и напрямую программами .NET
Framework, однако обычно это менее удобно, чем использование MSMQ, и может быть связано с дополнительными
затратами – служба MSMQ уже входит в большинство систем семейства Windows. Использование моста MSMQMQSeries позволяет создавать гетерогенные распределенные системы на основе обмена сообщениями, поскольку
технология IBM MQ является изначально межплатформенной.
Приложение может вести поиск нужной ему очереди по ряду критериев. Это возможно при использовании
механизма общих очередей в Microsoft Message Queuing, что требует развертывания Microsoft Active Directory.
5.2. Инфраструктура, необходимая для использования MSMQ
Служба MSMQ может работать как в составе домена Active Directory, так и при отсутствии такого домена, но во
втором случае невозможно использовать ряд возможностей MSMQ, а именно:

не поддерживается шифрование передаваемых сообщений;

не поддерживаются общие очереди и механизмы их обнаружения;

не поддерживается маршрутизация сообщений и групповая рассылка сообщений.
В MSMQ существуют два вида очередей – общие (public) и частные (private). Как частные, так и общие очереди
могут либо использовать, либо не использовать транзакции, что задается при создании очереди и не может быть
изменено в дальнейшем.
Информация об общих очередях публикуется в службе каталогов Active Directory. Путь к общей очереди имеет вид
ComputerName\QueueName, возможна также запись пути в виде .\QueueName для очереди на локальном
компьютере. Посылающее сообщение приложение может искать доступные в домене общие очереди по заданным
критериям. Возможна также проверка приложением наличия общей очереди на удаленном компьютере и ее
создание. Для использования общих очередей требуется развертывание MSMQ в рамках домена Active Directory.
Частные очереди доступны как при наличии домена, так и при его отсутствии. Путь к такой очереди имеет вид
ComputerName\Private$\QueueName или .\Private$\QueueName для локального компьютера. Приложение, не имеет
возможности ни создать, ни проверить наличие частной очереди на удаленном компьютере при использовании
средств библиотеки FCL.
В MSMQ 3.0 появилась возможность посылать сообщения в общую или частную очередь по протоколу HTTP при
наличии на удаленном компьютере службы Internet Information Services (IIS). В этом случае используется путь к
очереди вида http://domain.name/msmq/private$/queuename. Посылающий сообщения компьютер так же должен
поддерживать HTTP для MSMQ, иначе он не сможет получать какие-либо ответы. При чтении сообщений
использовать HTTP-формат имени очереди невозможно.
MSMQ поддерживает два вида имени очереди – прямой вид (direct name) и путь к очереди (path name). При
использовании частных очередей на удаленном компьютере обычно необходимо использовать прямой путь к
очереди. При использовании MSMQ программами на .NET Framework прямой путь записывается следующим
образом:

Formatname:DIRECT=OS:server01\QueueName – прямое имя общей очереди на компьютере server01;

Formatname:DIRECT=OS:ws02\Private$\QueueName – прямое имя частной очереди на компьютере ws02;

Formatname:DIRECT=TCP:192.168.30.1\private$\QueueName – прямое имя частной очереди на компьютере с
адресом 192.168.30.1.
Полноценная работа с очередями возможна только в пределах локальной или виртуально частной сети, поскольку
при чтении сообщений используется Windows RPC (в частности, обращения на 135-й порт). Кроме этого, среда
MSMQ не способна функционировать при использовании NAT, за исключением случая HTTP-имени очереди.
5.3. Применение службы сообщений MSMQ в распределенных системах
Рассмотрим возможности, предоставляемые службой MSMQ как промежуточным программным обеспечением с
точки зрения требований, предъявляемых к распределенной системе.

Открытость. Требование выполняется частично: используя в качестве сообщения XML-документ с заданной
XSD-схемой, можно добиться открытости передаваемых данных. Однако сама технология MSMQ является закрытой
и одноплатформенной.

Безопасность. MSMQ поддерживает обычные для Windows NT списки управлением доступа (ACL) для каждой
очереди, а при наличии домена AD – прозрачное шифрование сообщений. Таким образом, система, использующая
MSMQ, может являться безопасной при развертывании в пределах домена Active Directory.

Расширяемость. MSMQ позволяет создавать масштабирумые системы, поскольку не накладывает
ограничений на число машин, считывающих сообщения из одной очереди. Если время обработки сообщения
удаленным приложением несравнимо больше времени на его пересылку между очередями, то возможен линейный
рост производительности при увеличении числа компьютеров, считывающих и обрабатывающих сообщения из
очереди.

Обеспечение целостности данных. MSMQ поддерживает внутренние транзакции, распределенные
транзакции среды COM+ и транзакции из System.Transactions. Внутренние транзакции гарантируют, что некоторая
последовательность операций компоненты с очередями (например, получение сообщение и отправка ответа на него)
будет либо выполнена полностью, либо не выполнена вообще. Транзакции среды COM+ и пространства имен
System.Transactions используют координатор распределенных транзакций (MS DTC). При их использовании в
последовательность операций, образующих транзакцию, кроме действий с очередями сообщений могут входить
операции с любыми службами, поддерживающие распределенные транзакции. Кроме использования транзакций,
для повышения надежности в MSMQ следует использовать механизм восстанавливаемых сообщений, который
повышает вероятность того, что после принятия службой MSMQ сообщение не будет потеряно при аварийном
отключении питания. Распределенные транзакции COM+ будут рассмотрены в следующем разделе.

Устойчивость. Основной особенностью MSMQ является возможность использования нескольких читающих из
очереди серверов. Кроме того, при использовании общих очередей возможен выбор того или иного компьютера с
требуемой очередью. В силу этого при использовании очередей сообщений можно избежать возникновения
уникальной точки уязвимости.
Таким образом, с точки зрения требований к распределенной системе технология MSMQ обладает
многочисленными достоинствами. Однако данная технология промежуточного ПО также имеет ряд важных
недостатков.

Использование сообщений происходит непрозрачно для приложения, в отличие от использования
механизмов удаленного вызова.

MSMQ неудобно использовать вне LAN/VPN. Если какой-либо компоненте нужно посылать сообщения по
протоколу HTTP и при этом получать ответы с результатом обработки своих сообщений, то вероятно
предпочтительнее либо использовать VPN, либо рассмотреть вариант использования синхронных удаленных
вызовов.

Для реализации модели "запрос-ответ" при использовании MSMQ предпочтительно применять отдельную
очередь ответов для каждой посылающей запросы компоненты.
Использование очередей, поддерживающих транзакции, отличается от использования очередей без поддержки
транзакций, причем использование внутренних и внешних транзакций заметно отличается. Работа с частными
очередями может отличаться от работы с общими очередями. В свою очередь набор возможных операций с
частными локальных очередями (.\Private$\LocalQueueName) отличается от такового для удаленных частных
очередей (SomeComputer\Private$\RemoteQueueName). Поэтому при использовании MSMQ, как и других
промежуточных сред, рекомендуется создать промежуточный слой взаимодействия с ним. Такой слой скрывал бы
использование очередей от вышестоящих компонент и позволял безболезненно перейти от частных к общим
очередям или наоборот, от внутренних транзакций ко внешним и упростил бы переход на другое промежуточное
программное обеспечение.
Службы очередей сообщений находят наилучшее применение в случаях, когда какая либо компонента
распределенной системы посылает заявки, не требующие ответа (модель "запрос"). Если же компонента получает
некоторые ответы в асинхронном режиме (модель "запрос-ответ"), то она должна, вероятно, поддерживать
собственный список ожидающих ответов заявок. Это означает наличие у компоненты некоторого внутреннего
состояния, которое должно сохраняться в течение длительного времени. Наличие такого состояния является
недостатком с точки зрения концепции распределенной системы как набора сервисов, не сохраняющих историю
своих вызовов. С точки зрения этой концепции использующая MSMQ компонента либо дожидается ответа сервера в
течение одного своего вызова другими компонентами, либо не нуждается в ответе вообще. В первом случае MSMQ
предпочтительнее технологий удаленного вызова в одном из в следующих случаев:

обеим взаимодействующим компонентам известен только посредник (компьютер с используемой очередью
сообщений);

заявки обрабатываются несколькими компьютерами параллельно;

вызывающая компонента не знает внешний интерфейс удаленного вызова вызываемой компоненты.
Наличие хороших возможностей масштабирования у систем, использующих очереди сообщений, может быть
одним из доводов в пользу выбора такой технологии в качестве промежуточной среды. В частности, одним из
возможных приложений MSMQ является создание вычислительных распределенных приложений, реализующих
какие либо численные методы, поскольку в настоящий момент MSMQ является практически единственным
доступным при использовании .NET Framework средством обмена сообщениями, которое может быть использовано
для разработки параллельных вычислительных приложений. Поскольку накладные расходы на использование
очередей сообщений достаточно существенны, то использование очередей сообщений оправдано в тех случаях,
когда выполняемая на удаленном компьютере задача выполняется значительное время (порядка десятых долей
секунды и более).
Отдельным вопрос при использовании службы MSMQ является решение такой проблемы, как единственность
используемой очереди. Поскольку очередь находится на каком либо заданном компьютере, она является узким
местом с точки зрения устойчивости и расширяемости системы. К сожалению, при использовании MSMQ из .NET
Framework нет возможности узнать, например, среднюю длину или время нахождения заявок в очереди для выбора
приложением одной из нескольких очередей. Для увеличения устойчивости системы можно было бы выбирать
работающую очередь из нескольких возможных, но для проверки готовности компьютера с удаленной очередью
видимо скорее имеет смысл реализовать посылку тестового пакета ICMP, чем дожидаться от MSMQ известия о
невозможности послать сообщение в очередь. Таким образом, решение вопроса балансировки нагрузки на
менеджеры очередей и дублирование их функций в настоящий момент остается за разработчиком распределенной
системы.
5.4. Использование очередей сообщений MSMQ в .NET Framework
Для работы с очередями сообщений используются классы из пространства имен System.Messaging. Класс
System.Messaging.MessageQueue содержит три группы методов.

Статические методы для администрирования очередей: Create, Delete, Exists, Purge.

Методы поиска общих очередей: GetPublicQueues, GetPublicQueuesByLabel и другие. При их использовании
можно создать приложение, которое переключается между несколькими менеджерами очередей в пределах Active
Directory, если один из них выходит из строя.

Методы для работы с сообщениями (Send, Receive, Peek и другие), в том числе позволяющие использовать
обработчик на завершение операции (BeginPeek, BeginReceive).
При применении классов из System.Messaging возможно три варианта работы с очередями сообщений:

работа с очередями, не использующими транзакции;

работа с очередями, поддерживающими транзакции, при использовании внутренних транзакций MSMQ;

работа с очередями, поддерживающими транзакции, при использовании распределенных транзакций COM+.
Определенной трудностью при использовании MSMQ в .NET Framework являются различия по использованию
разных видов очередей. В частности, для очередей без транзакций можно установить обработчик на завершение
приема сообщения, а для очередей с транзакциями этот способ неприемлем, поскольку само чтение сообщения
должно быть оформлено как часть транзакции. Для обоих видов очередей можно поставить обработчик на появление
сообщения в очереди, что и является рекомендованным способом.
Для сериализации и десериализации сообщений MSMQ могут использоваться классы XMLMessageFormatter или
BinaryMessageFormatter из пространства имен System.Messaging. Класс XMLMessageFormatter использует класс
System.Xml.Serialization.XmlSerializer, описанный ранее в теме о сериализации, поэтому при использовании
XMLMessageFormatter должны учитываться все особенности использования класса XmlSerializer. Класс
BinaryMessageFormatter аналогичным способом использует для сериализации класс BinaryFormatter.
Поскольку классы BinaryFormatter и XmlSerializer имеют различные ограничения на сериализуемые классы и
используют совершенно различные процедуры сериализации, в нетривиальном случае переход
BinaryMessageFormatter на XMLMessageFormatter или наоборот может привести к определенным изменениям в
исходном коде программных компонент. Рекомендованным для использования с MSMQ следует считать
XMLMessageFormatter. Его применение позволяет создать XSD схему для передаваемого сообщения. При
использовании MSMQ ни значительно меньший объем сообщения, создаваемого классом BinaryMessageFormatter, ни
его меньшее время работы не является принципиальными факторами.
Ниже рассмотрено вспомогательное пространство имен с классами общего вида, реализующими модель "запросответ" при использовании внутренних транзакций MSMQ (рис. 5.2).
Рис. 5.2. Обслуживание запросов клиентов при использовании MSMQ
Программа использует пространство имен с классами передачи сообщений System.Messaging и пространство
имен с коллекциями общего вида.
using System;
using System.Messaging;
using System.Collections.Generic;
Классы используют два делегата общего вида, которые будут связаны с событиям обработки сообщения
сервером и получения ответа клиентом.
namespace Seva.Msmq
{
// типы очередей
enum QueueType {NonTransactional, Transactional};
// типы классов форматирования
enum QueueFormatter {Binary, Xml};
// делегат общего вида для обработки сервером сообщений клиента
delegate AnswerType ProcessRequestEventHandler
<RequestType, AnswerType>(Object sender, RequestType request,
MessageQueue queueResponse);
// делегат общего вида для обработки ответов сервера клиентом
delegate void ProcessAnswerEventHandler<RequestType, AnswerType>
(Object sender, RequestType request, AnswerType answer);
Абстрактный класс MSMQUser, наследуемый классами MSMQServer и MSMQClient.
public abstract class MsmqUser
{
// использование восстанавливаемых сообщений
private bool recoverable = false;
public bool Recoverable
{
get {
return recoverable;
}
set {
recoverable = value;
}
}
// объекты форматирования для посылки приема сообщений
protected IMessageFormatter requestFormatter;
protected IMessageFormatter answerFormatter;
//
public MsmqUser(QueueFormatter formatterType)
{
if (formatterType == QueueFormatter.Xml)
{
requestFormatter = new XmlMessageFormatter(
new Type[]{typeof(RequestType)});
answerFormatter = new XmlMessageFormatter(
new Type[]{typeof(AnswerType)});
}
if (formatterType == QueueFormatter.Binary)
{
requestFormatter = new BinaryMessageFormatter();
answerFormatter = new BinaryMessageFormatter();
}
}
}
Листинг 5.1.
Класс общего вида, посылающий через MSMQ запросы и получающий ответы на них.
class MsmqClient<RequestType, AnswerType> :
MsmqUser<RequestType, AnswerType>, IDisposable
{
// очереди для отсылки запросов и приема ответов
private MessageQueue queueSend;
private MessageQueue queueReceive;
// список необслуженных запросов
private Dictionary<String, RequestType> messages;
public Dictionary<String, RequestType> Messages
{
get { return messages;}
}
// событие, вызываемое при приеме ответа
public event ProcessAnswerEventHandler<RequestType, AnswerType>
ProcessAnswer;
Конструктор, получающий имена очередей для посылки и приема сообщений.
public MsmqClient(String queueSendName, String queueReceiveName,
QueueFormatter formatterType): base(formatterType)
{
// список отправленных сообщений без ответов
messages = new Dictionary<String,RequestType>();
// создание очереди для посылки запросов, если она не существует
queueSend = MsmqTools.CreateQueue(queueSendName,
QueueType.Transactional);
// создание очереди для приема ответов, если она нужна
if (queueReceiveName != null)
{
queueReceive = MsmqTools.CreateQueue(queueReceiveName);
queueReceive.Formatter = answerFormatter;
// считывать из очереди свойство CorrelationId
queueReceive.MessageReadPropertyFilter.CorrelationId = true;
}
else
{
queueReceive = null;
}
}
В методе Dispose происходит закрытие используемых очередей.
public void Dispose()
{
queueSend.Close();
queueSend.Dispose();
if (queueReceive != null)
{
queueReceive.Close();
queueReceive.Dispose();
}
}
Функции BeginReceive и EndReceive начинают и прекращают прием ответов сервера, изменяя обработчик события
PeekComplete очереди ответов.
public void BeginReceive()
{
// установить обработчик на событие, возникающее при появлении
// сообщения в очереди
queueReceive.PeekCompleted += OnPeek;
// начать отслеживание поступления сообщения в очередь
queueReceive.BeginPeek();
}
// прекратить прием ответов сервера
public void EndReceive()
{
// отключить обработчик
queueReceive.PeekCompleted -= OnPeek;
}
Функция Send посылает в исходящую очередь запрос общего типа для его обработки сервером. Для ответа на
сообщение серверу следует использовать очередь, указанную в поле ResponseQueue посылаемого сообщения.
public void Send(RequestType request)
{
// создание нового сообщения
Message message = new Message(request, requestFormatter);
message.ResponseQueue = queueReceive;
// использование восстаналиваемых сообщений
message.Recoverable = Recoverable;
// послать сообщение; поскольку транзакция состоит из
// единственной операции, вместо объекта-транзакции используется
// значение MessageQueueTransactionType.Single
queueSend.Send(message, MessageQueueTransactionType.Single);
// поле message.Id устанавливается после посылки сообщения;
// идентификатор сообщения связывается c отосланным запросом
// в списке необслуженных запросов
messages.Add(message.Id, request);
}
Обработчик события очереди PeekComplete использует внутренние транзакции MSMQ. В одну транзакцию входит
операция чтения ответа из очереди и последующий вызов события ProcessAnswer. Если в ходе обработки события
возникло исключение, ответ сервера останется в очереди ответов. Иначе сообщение удаляется из поддерживаемого
клиентом списка невыполненных запросов.
public void OnPeek(Object source, PeekCompletedEventArgs asyncResult)
{
// создание внутренней транзакции MSMQ
MessageQueueTransaction transaction = new MessageQueueTransaction();
// начало транзакции
transaction.Begin();
try
{
// прекратить ожидание сообщений в очереди
queueReceive.EndPeek(asyncResult.AsyncResult);
// получить сообщение из очереди в рамках транзакции
Message message = queueReceive.Receive(transaction);
// в поле CorrelationId должен быть идентификатор сообщения
// с исходным запросом
String messageId = message.CorrelationId;
// есть ли такое сообщение в списке невыполненных запросов?
if (messages.ContainsKey(messageId))
{
if (message.Body is AnswerType)
{
// преобразовать тело сообщения к типу ответа
// и вызвать событие по его обработке
AnswerType answer = (AnswerType) message.Body;
ProcessAnswer(this, messages[messageId], answer);
};
messages.Remove(messageId);
}
// продолжить ожидать сообщения
BeginReceive();
// успешное завершение транзакции
transaction.Commit();
}
catch (Exception e)
{
// отмена транзакции
transaction.Abort();
throw e;
}
}
}
Листинг 5.2.
MSMQServer – класс общего вида, принимающий через MSMQ запросы и посылающий ответы на них.
class MsmqServer<RequestType, AnswerType>:
MsmqUser<RequestType, AnswerType>, IDisposable
{
// очередь приема запросов
private MessageQueue queueReceive;
// событие, вызываемое при приеме запроса
public event ProcessRequestEventHandler<RequestType, AnswerType>
ProcessMessage;
Конструктор класса проверяет наличие очереди.
public MsmqServer(String queueReceiveName, QueueFormatter formatterType):
base(formatterType)
{
// создание очереди приема сообщений, если она не существует
queueReceive = MsmqTools.CreateQueue(queueReceiveName,
QueueType.Transactional);
queueReceive.Formatter = requestFormatter;
}
В методе Dispose происходит закрытие используемых очередей.
public void Dispose()
{
queueReceive.Close();
queueReceive.Dispose();
}
Функции BeginReceive и EndReceive начинают и прекращают прием ответов сервера, изменяя обработчик события
PeekComplete очереди ответов.
// начать прием запросов от клиента
public void BeginReceive()
{
queueReceive.PeekCompleted += OnPeek;
queueReceive.BeginPeek();
}
// прекратить прием запросов от клиента
public void EndReceive()
{
queueReceive.PeekCompleted -= OnPeek;
}
Метод OnPeek – обработчик события PeekCompleted очереди с запросами. В одну транзакцию входит две
операции с очередями – чтения запроса и отправка ответа на него. Для обработки принятого сообщения и создания
ответа на него вызывается событие ProcessMessage. В поле ResponseQueue полученного сообщения содержится
ссылка на очередь, в которую следует отправить ответ на обработанный запрос.
// обработчки события PeekCompleted очереди с запосами
public void OnPeek(Object source, PeekCompletedEventArgs asyncResult)
{
// создание внутренней транзакции MSMQ
MessageQueueTransaction transaction = new MessageQueueTransaction();
// начало транзакции
transaction.Begin();
try
{
queueReceive.EndPeek(asyncResult.AsyncResult);
// прием cообщения в рамках транзакции
Message message = queueReceive.Receive(transaction);
// в поле ResponseQueue содержится ссылка на очередь,
// куда следует послать ответ на запрос
MessageQueue queueResponse = message.ResponseQueue;
try
{
if (message.Body is RequestType)
{
RequestType request = (RequestType) message.Body;
// вызвать событие обработки запроса
AnswerType answer = ProcessMessage(this, request,
queueResponse);
if ((queueResponse != null) && (answer != null))
{
Message answerMessage = new Message(answer,
answerFormatter);
answerMessage.Label = "Answer";
answerMessage.CorrelationId = message.Id;
answerMessage.Recoverable = Recoverable;
// послать собщение в рамках транзакции
queueResponse.Send(answerMessage, transaction);
}
}
}
finally
{
if (queueResponse != null)
{
queueResponse.Close();
queueResponse.Dispose();
}
};
// продолжить прием запросов
BeginReceive();
// завершить транзакцию
transaction.Commit();
}
catch (Exception e)
{
// отменить транзакцию в случае ошибки
Console.WriteLine(e);
transaction.Abort();
throw e;
}
}
}
Листинг 5.3.
Класс MsmqTools содержит вспомогательный статический метод для создания очереди сообщений.
static class MsmqTools
try
{
{
static public MessageQueue CreateQueue(String
if (!MessageQueue.Exists(queueName))
queueName)
{
{
MessageQueue.Create(queueName,
return CreateQueue(queueName,
type == QueueType.Transactional);
QueueType.Transactional);
}
}
}
// функция проверяет наличие очереди и создает
catch(Exception)
ее при необходимости
{
static public MessageQueue CreateQueue(String
}
queueName,
MessageQueue messageQueue = new
QueueType type)
MessageQueue(queueName);
{
return messageQueue;
MessageQueue messageQueue;
}
// если это частная очередь удаленного
}
компьютера,
}
// то при попытке проверки ее наличие
возникает исключение
Следует отметить, что при работе с общими очередями можно обращаться к очереди по ее пути, например
следующим образом.
queueName = @"Server\PublicQueue";
При использовании частных очередей на удаленном компьютере в большинстве случаев требуется применять
прямое имя очереди.
queueName = @"Formatname:DIRECT=OS:Computer\Private$\PrivateName";
Имена используемых очередей следует хранить в конфигурационном файле программы.
5.5. Выводы по использованию MSMQ
Промежуточная среда Microsoft Message Queuing обеспечивает асинхронный обмен сообщениями и может быть
использована программными компонентами распределенной системы в одном из следующих случаях:

необходимо организовать параллельную обработку заявок несколькими компьютерами;

одна компонента посылает другой запросы без получения ответов на них;

взаимодействие компонент не должно быть синхронным;

требуется интеграция с какими-либо другими независимыми системами, которые могут использовать очереди
сообщений (MSMQ или IBM MQ).
Альтернативным способом использования MSMQ являются отложенные компоненты (queued components) среды
COM+, которые будут рассмотрены в разделе, посвященном COM+. При использовании отложенных компонент
MSMQ теряет одно из своих достоинств – клиент должен иметь доступ к интерфейсу удаленной компоненты, как и в
случае использования любых других COM+ компонент. Кроме того, существует возможность использовать MSMQ как
канал в .NET Remoting, для чего необходимо создать собственный канал, что будет проделано в соответствующей
теме. Таким образом, MSMQ является не только самостоятельной промежуточной средой, но и может быть
использовано другими промежуточными средами как асинхронный канал передачи данных.