NET中使用消息队列通讯

一、消息队列的基础知识

    1、定义
         “消息”是在两个进程间传送的数据单位。消息可以非常简单，例如只包含文本字符串；也可以更复杂，可能包含嵌入对象。
         消息被发送到队列中。“消息队列”是在消息的传输过程中保存消息的容器。消息队列管理器在将消息从它的源中继到它的目标时充当中间人。队列的主要目的是提供路由并保证消息的传递；如果发送消息时接收者不可用，消息队列会保留消息，直到可以成功地传递它。
         “消息队列”是 Microsoft 的消息处理技术，这两个进程可以在同一台机器上，也可以在整个网络中，甚至是位于并不总是连接在一起的不同机器上。MSMQ具有故障保险特性，因为如果第一次传送失败，它会重新发送消息。这样可保证你的应用程序消息到达它们的目的地。

    2、优点
         消息队列为基于服务器的应用程序组件之间的进程间通信提供了强大灵活的机制。同组件间的直接调用相比，消息队列有一下优点：
         稳定性 — 组件失败对消息的影响程度远远小于组件间的直接调用，因为消息存储在队列中并一直留在那里，直到被适当地处理。消息处理同事务处理相似，因为消息处理是有保证的。
         消息优先级 — 更紧急或更重要的消息可在相对不重要的消息之前接收，因此可以为关键的应用程序保证足够的响应时间。
         脱机能力 — 发送消息时，它们可被发送到临时队列中并一直留在那里，直到被成功地传递。当因任何原因对所需队列的访问不可用时，用户可以继续执行操作。同时，其他操作可以继续进行，如同消息已经得到了处理一样，这是因为网络连接恢复时消息传递是有保证的。
         事务性消息处理 — 将多个相关消息耦合为单个事务，确保消息按顺序传递、只传递一次并且可以从它们的目标队列中被成功地检索。如果出现任何错误，将取消整个事务。 
         安全性 - MessageQueue 组件基于的消息队列技术使用 Windows 安全来保护访问控制、提供审核并对组件发送和接收的消息进行加密和验证。

    3、分类
         队列可分为用户队列和系统队列。用户队列可有您或网络中的其他用户创建的，系统队列是由系统创建。
         用户队列可分为：
         公共队列”在整个“消息队列”网络中复制，可被网络中的所有主机访问。
         专用队列”不在整个网络中发布,仅驻留在本地计算机上。专用队列只能由知道队列的完整路径名或标签的应用程序或本机应用程序访问。 
         “管理队列”包含确认在给定“消息队列”网络中发送的消息回执的消息。
         “响应队列”包含目标应用程序接收到消息时返回给发送应用程序的响应消息。
         系统队列可分为：
         “日记队列”可选地存储发送消息的副本和从队列中移除的消息副本。每个“消息队列”客户端上的单个日记队列存储从该计算机发送的消息副本。在服务器上为每个队列创建了一个单独的日记队列。此日记跟踪从该队列中移除的消息。 
         “死信队列”存储无法传递或已过期的消息的副本。如果过期消息或无法传递的消息是事务性消息，则被存储在一种特殊的名为“事务性死信队列”的死信队列中。 
         “报告队列”包含指示消息到达目标所经过的路由的消息，还可以包含测试消息。每台计算机上只能有一个报告队列。 
         “专用系统队列”是一系列存储系统执行消息处理操作所需的管理和通知消息的专用队列。
    4、同步和异步通信
         队列通信在本质上是“异步”的，因为将消息发送到队列和从队列中接收消息是在不同的进程中完成的。另外，还可以异步执行接收操作。希望接收消息的用户可以针对任何给定的队列调用 BeginReceive 方法，然后立即执行其他任务，而无需等待回复。这与人们所了解的“同步通信”截然不同。 
         在同步通信中，请求的发送方在执行其他任务前，必须等待来自预定接收方的响应。发送方等待的时间完全取决于接收方处理请求和发送响应所用的时间。
    5、消息安全性
         可用如下方式帮助保护发送和接收的消息内容： 
         可使用身份验证验证应用程序接收的消息的来源。 
         可使用加密确保未经授权的人无法读取或使用您的消息。 
         可以使用访问控制权限，用基于 ACL 的安全性限制用户并用代码访问安全性限制代码向计算机上的特定队列发送消息或从中读取消息。
         可使用审核记录尝试访问“消息队列”对象的用户，尝试的操作类型，以及该访问成功还是失败。

二、安装消息队列

          在WINDOWS NT系统中MSMQ是WINDOW组件存在的，需要通过“添加/删除WINDOW”组件来安装。选择“应用程序服务器--详细信息--消息队列”完成安装即可。打开“计算机管理”在“服务和应用程序”菜单中可看到“消息队列”项，在这里可以对消息队列进行创、配置与管理。

三、NET中使用消息队列编程
    在NET框架中提供了MessageQueue 组件来处理消息队列。
    1、创建队列
        创建公用队列：MessageQueue.Create(@"MachineName/MyQueue") 。 MachineName为计算机名称，可以使用"."来表示本机。
        创建专用队列：MessageQueue.Create(@"./Private$/MyPrivateQueue") 。指定所需的语法 Private$来创建专用队列
    2、队列引用
        有三种方法可以在代码中引用一个队列：
        通过路径 — 唯一标识计算机和感兴趣的队列的名称的路径。
        通过格式名 — 队列的唯一标识符，创建队列时由 MSMQ 生成，或者后来由应用程序生成。
        通过标签 — 可能不唯一的描述性队列名称，创建队列时由队列管理员指派。
        使用路径引用队列:
        公共队列     MachineName/QueueName       
        专用队列     MachineName/Private$/QueueName   
        日记队列     MachineName/QueueName/Journal$   
        计算机日记队列     MachineName/Journal$       
        计算机死信队列     MachineName/Deadletter$   
        计算机事务性死信队列 MachineName/XactDeadletter$   
        使用格式名引用队列
        队列类型    格式名中使用的语法 
        公共队列    FORMATNAME:PUBLIC=QueueGUID
        专用队列    FORMATNAME:PRIVATE=MachineGUID/QueueNumber
        日记队列    FORMATNAME:PUBLIC=QueueGUID;JOURNAL - 或 - FORMATNAME:PRIVATE=MachineGUID/QueueNumber;JOURNAL
        使用标签引用队列:还可通过队列的标签引用队列，标签是由队列管理员赋予队列的一个描述性文本标签。标签不总是唯一的，因此如果在试图使用特定队列的标签连接到该队列时存在名称冲突，将会收到错误信息。
    3、删除消息队列
        MessageQueue.Delete(@"myMachine/MyQueue");
    4、清除队列的内容
        System.Messaging.MessageQueue MessageQueue1 = new System.Messaging.MessageQueue();
        MessageQueue1.Path = @"./MyQueue";
        MessageQueue1.Purge();
    5、发送信息
        MessageQueue mq = new MessageQueue(_path);           
        mq.Send("Hello!");
        MessageQueue不但可以发送简单的文本，还可以发送可序列化的任何数据类型，并且我们还可以通过显式创建 Message 对象来获得对消息的更多控制
        发送消息时需要关注的一些属性：
        消息优先级：Priority
        确认和响应属性:AcknowledgeType 和 AdministrationQueue
        日志属性:UseJournalQueue
        超时属性： TimeToReachQueue 
    6、读取与接收信息
        有几种方法可从系统的队列中读取和接收消息。
        首先，可以从队列中接收消息，或可以在队列上查看消息而不移除它们。
        此外，还可以创建事件处理程序来监视新到达的消息，并在消息到达队列时自动引发事件
    7、检索消息
            锁定对队列的访问：mq.DenySharedReceive = true;
            设置要检索的属性：
            指定消息的格式：Message msg = mq.Receive(new TimeSpan(0, 0, 2));   msg.Formatter = new XmlMessageFormatter(new Type[] { typeof(MSMQ.Order) });
            获取信息：IOrder order = (IOrder)msg.Body;
        查看消息：可以使用 Peek 方法查看任何队列中的第一个消息，但不将该消息从队列中移除。
        检索静态消息列表：messageQueue.GetAllMessages();
        检索动态消息列表：messageQueue.GetMessageEnumerator2();

        检索公共队列或专用队列的静态列表：       
            创建 MessageQueue 类型的数组以存放查询结果。
            调用 MessageQueue 类的适当方法：GetPublicQueues、GetPrivateQueuesByMachine、GetPublicQueuesByCategory、GetPublicQueuesByLabel、GetPublicQueuesByLabel
            将结果指派到数组。
        检索动态队列列表：
            创建 MessageQueueEnumerator 对象以存放查询结果。
            调用 MessageQueue 类的 GetMessageQueueEnumerator 方法。
            若要检索网络上的队列的子集，请将 MessageQueueCriteria 参数设置为适当的值。
            将结果设置为所创建的 MessageQueueEnumerator 对象。
    8、消息队列安全性
        “消息队列”利用了 Windows 操作系统的各种内置的访问控制、身份验证、加密和审核来获得安全性：
        1、访问控制用于限制用户对“消息队列”对象的访问，并通过为对象指派安全描述符来实现。“消息队列”对象包括计算机 (MSMQ)、队列、路由链接和消息队列设置对象。安全描述符列出被授予或拒绝访问对象的用户和组，以及指派给那些用户和组的特定权限。
        2、身份验证是使用公钥证书、Kerberos V5 安全协议和 Windows NTLM（为了与运行在 Windows NT 4.0 上的“消息队列”1.0 兼容）来实现的。公钥证书用于消息的身份验证，也就是向“消息队列”服务器验证消息的发送方（客户端）。Kerberos V5 和 NTLM 用于服务器身份验证，也就是向客户端验证“消息队列”服务器。
        3、加密使用公钥（不对称）和密钥（对称）两者来实现。“消息队列”应用程序使用加密来加密消息队列计算机之间发送的消息。
        4、审核用于记录试图访问 Active Directory 中的“消息队列”对象的用户。对象的安全描述符指定要为该对象审核的各种访问事件。

四、消息队列的高级编程

    异步消息处理
        如果想检索消息但不阻碍应用程序的处理，可异步检索消息。在异步消息处理中，启动任务的方法被立即返回而不等待结果。应用程序可以在任务完成过程中继续它原来的工作。任务完成时，服务器可以通知应用程序消息已被成功处理。
        有两种类型的异步消息处理操作：异步接收消息和异步查看消息。异步检索消息时，使用 BeginReceive 方法和 EndReceive 方法标记操作的开始和结束。所发生的操作如下所示：
        当队列上的消息变得可用时，或者如果要查看或接收的消息已经存在，BeginReceive 方法将立即返回，并引发名为 ReceiveCompleted 的事件。
        ReceiveCompleted 事件返回一个 IAsyncResult 类型的对象，该对象包含有关异步操作的信息。 接收到完成的事件后，调用 EndReceive 方法完成操作。在最后的调用中，可以访问消息或通过访问 ReceiveCompletedEventArgs 类检索该消息。
        与 Receive 一样，Peek 使用两个名为 BeginPeek 和 EndPeek 的方法来标记异步操作的开始和结束。
    事务性消息处理
        利用事务性处理，您可以确保事务中的消息按照顺序传送，只传送一次，并且从目的队列成功地被检索。MessageQueue 组件可用于通过事务收发消息。当您在事务中发送消息时，可以将相关的消息归入一组。事务中包含的所有消息要么按发送顺序一起传送（“提交”的事务），要么在出现问题时自动停止收发（“中止”的事务）。
        从应用程序中，主要可以创建以下两种事务：
        “内部事务”用于在两个或多个“消息队列”资源之间发送消息。
        内部事务是通过创建 MessageQueueTransaction 类的实例并将该实例关联到 MessageQueue 组件的实例来执行的。
        内部事务的编程模型非常简单，只需调用 MessageQueueTransaction 类的 Begin 方法，并将此类的实例传递到收发方法。然后，调用 Commit 以将事务的更改保存到目标队列。
        “外部事务”用于在队列和其他资源（如数据库）之间发送消息。外部事务通常用于在队列和其他类型的资源之间发送消息。外部事务具有更加复杂的编程模型。您不仅仅是调用 Begin、Commit 和 Abort，而是指定表示外部事务的属性并将组件注册到 COM+ 1.0 服务。您还必须使用特殊形式的 Send 和 Receive 方法，这些方法采用事务类型的参数并将此字段设置为 Automatic。

五、C#操作消息队列代码

using  System;
using  System.Collections.Generic;
using  System.Text;
using  System.Messaging;
namespace  MSMQ
... {
    public class MessageHandle
    ...{
        private static string _path = @".Private$AAA"; //在本地专创建用队列。
        private static string _path2 = @".BBB";
        public static void SendMessage()
        ...{
            
            MessageQueue mq = new MessageQueue(_path);
            

           // mq.BasePriority = 3; //设置消息的优先级别
           // mq.DefaultPropertiesToSend.AcknowledgeType = AcknowledgeTypes.None;
          //  mq.UseJournalQueue = true;//设置是否保存日志
          //  mq.MaximumJournalSize = 102400;//设置日志的大小KB
           // mq.Authenticate = true;
          //  mq.DefaultPropertiesToSend.TimeToReachQueue = TimeSpan.FromHours(1);//设置到达队列的时间

           // mq.Send(DateTime.Now.ToString(), "Time");//发送简单消息
            Order o = new Order();
            o.Price = 80;
            mq.Send(o, "Order", MessageQueueTransactionType.None); //发送复杂消息
            mq.Close();
            mq.Dispose();
        }
        /**//// <summary>
        /// 接收并读取一条消息
        /// </summary>
        /// <returns></returns>
        public static string ReadMessage()
        ...{
            if (MessageQueue.Exists(_path))
            ...{
                MessageQueue mq = new MessageQueue(_path);
                mq.DenySharedReceive = true; //锁定对队列的接收访问
                try
                ...{
                    Message msg = mq.Receive(new TimeSpan(0, 0, 2));
                    //msg.Formatter = new XmlMessageFormatter(new string[] { "System.String,mscorlib" });  //读取文本数据
                    msg.Formatter = new XmlMessageFormatter(new Type[] ...{ typeof(MSMQ.Order) }); 
                    IOrder order = (IOrder)msg.Body;
                    string rtn = order.Total.ToString();
                    mq.Close();
                    mq.Dispose();
                    return rtn;
                }
                catch(Exception ex)
                ...{
                    mq.Close();
                    mq.Dispose();
                    return ex.Message;
                }
            }
            else
            ...{
                return "没找到队列";
            }
        }
        /**//// <summary>
        /// 循环读取消息队列
        /// </summary>
        /// <returns></returns>
        public static string ReadAllMessage()
        ...{
            if (MessageQueue.Exists(_path))
            ...{
                MessageQueue mq = new MessageQueue(_path);
                mq.DenySharedReceive = true; //锁定对队列的接收访问
                try
                ...{
                   
                    //循环读取队列
                    string rtn="";
                    MessageEnumerator me= mq.GetMessageEnumerator2();
                    while (me.Current != null)
                    ...{
                        Message msg = me.Current;
                        msg.Formatter = new XmlMessageFormatter(new Type[] ...{ typeof(MSMQ.Order) });
                        IOrder order = (IOrder)msg.Body;
                        rtn = order.Total.ToString();
                    }
                    mq.Close();
                    mq.Dispose();
                    return rtn;
                }
                catch (Exception ex)
                ...{
                    mq.Close();
                    mq.Dispose();
                    return ex.Message;
                }
            }
            else
            ...{
                return "没找到队列";
            }
        }
        public static int GetAllMessageQueue()
        ...{
            MessageQueue[] mq = MessageQueue.GetPrivateQueuesByMachine(@"."); //获取本地专用消息队列的个数
           return mq.Length;
        }
        /**//// <summary>
        /// 创建
        /// </summary>
        public static void CreateLocalQueue()
        ...{
            if (!MessageQueue.Exists(_path))
            ...{
                MessageQueue.Create(_path);
            }
        }
        /**//// <summary>
        /// 需创建域验证才能创建公用队列
        /// </summary>
        public static void CreateQueue()
        ...{
            if (!MessageQueue.Exists(_path2))
            ...{
                MessageQueue.Create(_path2);
            }
        }
        /**//// <summary>
        /// 删除队列
        /// </summary>
        public static void Delete()
        ...{
            if (MessageQueue.Exists(_path))
            ...{
                MessageQueue.Delete(_path);
            }
        }
    }
    [Serializable]
    public class Order : MSMQ.IOrder
    ...{
        public int ID = 0;
        public string Name = "";
        public float Price = 0.0f;
        public int Num = 1;
        public float Rate = 0.8f;
        /**//// <summary>
        /// 获取价格
        /// </summary>
        public float Total
        ...{
            get
            ...{
                return Price * Num * Rate;
            }
        }
    }
    public interface IOrder
    ...{
        float Total ...{ get; }
    }

}

六、参考信息
消息队列的详细信息请参考
http://www.microsoft.com/technet/prodtechnol/windowsserver2003/zh-chs/library/ServerHelp/ba646355-7d07-4676-bc6d-a1fbf56bbda7.mspx?mfr=true
MessageQueue的详细信息请参考
http://msdn2.microsoft.com/zh-cn/library/system.messaging.messagequeue_members(VS.80).aspx