MSMQ 消息队列 安装MSMQ 创建发送接收队例消息

MSMQ，微软消息队列。

　　一、MSMQ介绍和安装消息队列

　　使用消息队列的优点：稳定、消息优先级、脱机能力以及安全性。

　　消息队列分为用户创建的队列(专用队列)和系统队列，看下图所示(myQueue为自己创建的消息队列,msmqtriggersnotifiations为通用队列)：

　　对消息队列有了简单的了解后，使用MSMQ进行软件开发需要安装MSMQ，安装完后就该进入实际的开发阶段。具体的安装过程就是在控制面板里“添加/删除程序”下“添加/删除Windows组件”，完成添加就OK。安装完成后就可以通过交互界添加新的消息队列，详细如下图：

　　出了上面这种交互界面来创建MSMQ外，也可以通过编程来完成，.NET框架里的MessageQueue类下有一静态方法Create，用来完成消息队列的创建，其定义如下：

　　1//
2// 摘要:
3//     在指定的路径中创建非事务性“消息队列”队列。
4//
5// 参数:
6//    path:
7//      要创建的队列的路径。
8//
9// 返回结果:
10//      表示新队列的 System.Messaging.MessageQueue。
11public static MessageQueue Create(string path);
12//
13// 摘要:
14//      在指定的路径中创建事务性或非事务性“消息队列”队列。
15//
16// 参数:
17//    transactional:
18//      如果创建事务性队列，为 true；如果创建非事务性队列，则为 false。
19//
20//    path:
21//      要创建的队列的路径。
22//
23// 返回结果:
24//      表示新队列的 System.Messaging.MessageQueue。
25public static MessageQueue Create(string path, bool transactional);

　　实现消息队列的创建简单代码(C#)，创建一个名为"myQueue"的非事务性"消息队列"，如下：

　MessageQueue.Create(@".\private$\myQueue");

二、创建、删除和管理队列

　　在.NET环境下编写Message Queue程序的前提就是需要先安装MSMQ，本文之前已经作了详细的介绍。要开发MSMQ程序就必须学习一个很重要的类(MessageQueue)，该类位于名称空间System.Messageing下。其中有几个常用的方法必须掌握：

　　--Create方法:创建使用指定路径的新消息队列。

　　--Delete方法：删除现有的消息队列。

　　--Existe方法：查看指定消息队列是否存在。

　　--GetAllMessages()方法:得到队列中的所有消息。

　　--GetPublicQueues方法：在“消息队列”网络中定位消息队列。

　　--Peek/BeginPeek方法：查看某个特定队列中的消息队列，但不从该队列中移出消息。

　　--Receive/BeginReceive方法：检索指定消息队列中最前面的消息并将其从该队列中移除。

　　--Send方法：发送消息到指定的消息队列。

　　--Purge方法：清空指定队列的消息。

　　上述列举的方法在此就不作详细介绍，大家可以通过下面的示例程序中来体会他们各自的功能。

三、发送和序列化消息

　　MSMQ消息队列中定义的消息由一个主体(body)和若干属性构成。消息的主体可以由文本、二进制构成，根据需要还可以被加密。在MSMQ 中消息的大小不能够超过4MB。发送消息是通过Send方法来完成的，需要一个Message参数。

　　1、发送消息：

　　步骤：连接队列-->指定消息格式-->提供要发送的数据(主体)-->调用Send()方法将消息发送出去。详细见后面的示例程序。

　　2、序列化消息：

　　消息序列化可以通过.NET Framework附带的三个预定义格式化程序来完成：

　　-- XMLMessageFormatter对象----MessageQueue组件的默认格式化程序设置。

　　-- BinaryMessageFormatter对象;

　　-- ActiveXMessageFormatter对象;

　　由于后两者格式化后的消息通常不能为人阅读，所以我们经常用到的是XMLMessageFormatter对象。该对象构造方法有三种重载：

　　

      1public XmlMessageFormatter();
　　2public XmlMessageFormatter(string[] targetTypeNames);
　　3public XmlMessageFormatter(Type[] targetTypes);

　　如我们后面的示例程序中用到的序列化语句：

1//序列化为字符串
2XmlMessageFormatter formatter = new XmlMessageFormatter(new Type[] { typeof(string) });

四、读取和接收消息

　　1、读取消息：

　　也就是从指定队列中获取消息，详细请查看本文前面的关于消息操作的方法介绍。

　　2、接收消息有两种方式：

　　--> 通过Receive方法--具体功能请返回本文前面有详细介绍。

　　--> 通过Peek方法--具体功能请返回本文前面有详细介绍。

五、消息使用实例

　　通过上面一系列的介绍，了解了MessageQueue类和常用的方法后，下面我们通过一个简单的示例程序来分析消息队列的创建、发送消息以及接收消息等相关知识点：

　　1、通过Create方法创建使用指定路径的新消息队列

1/**//// <summary>
2/// 通过Create方法创建使用指定路径的新消息队列
3/// </summary>
4/// <param name="queuePath"></param>
5public static void Createqueue(string queuePath)
6{
7     try
8     {
9         if (!MessageQueue.Exists(queuePath))
10         {
11             MessageQueue.Create(@".\private$\myQueue");
12         }
13         else
14         {
15             Console.WriteLine(queuePath + "已经存在！");
16         }
17     }
18     catch (MessageQueueException e)
19     {
20         Console.WriteLine(e.Message);
21     }
22}

　　2、连接消息队列并发送消息到队列

1/**//// <summary>
2/// 连接消息队列并发送消息到队列
3/// </summary>
4public static void SendMessage()
5{
6     try
7     {
8         //连接到本地的队列
9         MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
10        
11         Message myMessage = new Message();
12         myMessage.Body = "消息内容";
13         myMessage.Formatter = new XmlMessageFormatter(new Type[] { typeof(string) });
14         //发送消息到队列中
15         myQueue.Send(myMessage);
16     }
17     catch (ArgumentException e)
18     {
19         Console.WriteLine(e.Message);
20     }
21}

　　3、连接消息队列并从消息队列中接收消息

1/**//// <summary>
2/// 连接消息队列并从队列中接收消息
3/// </summary>
4public static void ReceiveMessage()
5{
6     //连接到本地队列
7     MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
8     myQueue.Formatter = new XmlMessageFormatter(new Type[] { typeof(string) });
9     try
10     {
11         //从队列中接收消息
12         Message myMessage = myQueue.Receive();
13         string context = (string)myMessage.Body; //获取消息的内容
14         Console.WriteLine("消息内容为：" + context);
15     }
16     catch (MessageQueueException e)
17     {
18         Console.WriteLine(e.Message);
19     }
20     catch (InvalidCastException e)
21     {
22         Console.WriteLine(e.Message);
23     }
24}

　　4、连接队列并清空队列的全部消息

1/**//// <summary>
2/// 清空指定队列的消息
3/// </summary>
4public static void ClearMessage()
5{
6     MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
7     myQueue.Purge();
8}

　　5、连接队列并获取队列的全部消息

1/**//// <summary>
2/// 连接队列并获取队列的全部消息
3/// </summary>
4public static void GetAllMessage()
5{
6     //连接到本地队列
7     MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
8     Message[] message = myQueue.GetAllMessages();
9     XmlMessageFormatter formatter = new XmlMessageFormatter(new Type[] { typeof(string) });
10     for (int i = 0; i < message.Length; i++)
11     {
12         message[i].Formatter = formatter;
13         Console.WriteLine(message[i].Body.ToString());
14     }
15}

　　上面依次的列举出来5个方法，这里我就不做测试了。上述方法全部通过测试的。

六、复杂消息发送实例

　　通过上面一系列的介绍，对于简单消息的发送和接收及消息的管理应该都不会有什么问题了，下面我在介绍一下关于复杂的消息处理，现在有这样一个需求，要求通过消息队列将一本图书信息发送到队列里，然后从消息队列里读取出来。图书的基本信息包括图书编号、图书名称、图书作者以及图书定价，这样的一个复杂的对象类型怎么来传输呢?详细如下：

1namespace MSMQ.App
2{
3     public class MsgQueue
4     {
5         /**//// <summary>
6         /// 通过Create方法创建使用指定路径的新消息队列
7         /// </summary>
8         /// <param name="queuePath"></param>
9         public static void Createqueue(string queuePath)
10         {
11             try
12             {
13                 if (!MessageQueue.Exists(queuePath))
14                 {
15                     MessageQueue.Create(@".\private$\myQueue");
16                     MessageBox.Show("创建队列成功！");
17                 }
18                 else
19                 {
20                     MessageBox.Show(queuePath + "已经存在！");
21                 }
22             }
23             catch (MessageQueueException e)
24             {
25                 MessageBox.Show(e.Message);
26             }
27         }
28
29         /**//// <summary>
30         /// 连接消息队列并发送消息到队列
31         /// </summary>
32         public static bool SendMessage(Book book)
33         {
34             bool flag = false;
35             try
36             {
37                 //连接到本地的队列
38                 MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
39
40                 System.Messaging.Message myMessage = new System.Messaging.Message();
41                 myMessage.Body = book;
42                 myMessage.Formatter = new XmlMessageFormatter(new Type[] { typeof(MSMQ.App.Book) });
43                 //发送消息到队列中
44                 myQueue.Send(myMessage);
45                 flag = true;
46             }
47             catch (ArgumentException e)
48             {
49                 MessageBox.Show(e.Message);
50             }
51             return flag;
52         }
53
54         /**//// <summary>
55         /// 连接消息队列并从队列中接收消息
56         /// </summary>
57         public static string ReceiveMessage()
58         {
59             //连接到本地队列
60             MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
61             myQueue.Formatter = new XmlMessageFormatter(new Type[] { typeof(MSMQ.App.Book) });
62             try
63             {
64                 //从队列中接收消息
65                 System.Messaging.Message myMessage = myQueue.Receive();
66                 Book book = (Book)myMessage.Body; //获取消息的内容
67                 return string.Format("编号：{0},书名：{1},作者：{2},定价：{3}",
68                     book.BookId,
69                     book.BookName,
70                     book.BookAuthor,
71                     book.BookPrice);
72             }
73             catch (MessageQueueException e)
74             {
75                 MessageBox.Show(e.Message);
76             }
77             catch (InvalidCastException e)
78             {
79                 MessageBox.Show(e.Message);
80             }
81             return null;
82         }
83     }
84}

　　其实发送复杂的消息也就是在消息序列化上有些差别，别的地方与发送普通文本消息没什么大的变化，上面类里提供了创建队列，发送消息到队列，从队列获取消息三个方法。