MSMQ 消息队列的封装

介绍MSMQ 消息队列的文章很多，我不想多说，这里写了个对MSMQ 消息队列操作进行封装的类，做为自己初学MSMQ 消息队列的总结。代码如下：

/**/ /// <summary>
    /// 接受消息事件的代理
    /// </summary>
    /// <param name="src"></param>
    /// <param name="e"></param>
     public   delegate   void  MSReceivedEventHandler( object  src, MSReceiveEventArgs e);

     /**/ /// <summary>
    /// 消息发出后事件的代理
    /// </summary>
    /// <param name="src"></param>
    /// <param name="e"></param>
     public   delegate   void  MSSendedEventHandler( object  src, MSSendedEventArgs e);

发送消息的事件参数类
public class MSSendedEventArgs
    {
        private object msgContent;

        public object MsgContent
        {
            get
            {
                return this.msgContent;
            }
        }

        public MSSendedEventArgs(object msgContent)
        {
            this.msgContent = msgContent;
        }
    }

接受消息处理事件参数类
/**//// <summary>
    /// 接受消息处理事件参数类
    /// </summary>
    public class MSReceiveEventArgs
    {
        private Message msg;

        /**//// <summary>
        /// 接受的消息
        /// </summary>
        public Message Msg
        {
            get
            {
                return this.msg;
            }
        }

        private bool isAsyContinue;

        /**//// <summary>
        /// 接受消息后，是否再等待接受，在同步的情况下，此项无效
        /// </summary>
        public bool IsAsyContinue
        {
            get
            {
                return this.isAsyContinue;
            }
        }

        /**//// <summary>
        /// 接受消息处理事件参数类
        /// </summary>
        /// <param name="message">消息</param>
        public MSReceiveEventArgs(Message message)
        {
            this.msg = message;
            this.isAsyContinue = false;
        }

        /**//// <summary>
        /// 接受消息处理事件
        /// </summary>
        /// <param name="message">消息</param>
        /// <param name="isAsyContinue">接受消息后，是否再等待接受，在同步的情况下，此项无效</param>
        public MSReceiveEventArgs(Message message, bool isAsyContinue)
        {
            this.msg = message;
            this.isAsyContinue = isAsyContinue;
        }
    }

用MSMQ发消息的封装类
/**//// <summary>
    /// 用MSMQ发消息的消息类
    /// </summary>
    public class MSQueue
    {
        protected MessageQueueTransactionType transactionType = MessageQueueTransactionType.Automatic;
        protected MessageQueue queue;
        protected TimeSpan timeout;
        protected bool isAsyContinue = false;

        /**//// <summary>
        /// 接受消息后，是否再等待接受，在同步的情况下，此项无效
        /// </summary>
        public bool IsAsyContinue
        {
            get
            {
                return this.isAsyContinue;
            }
            set
            {
                this.isAsyContinue = value;
            }
        }


        /**//// <summary>
        /// 接受消息后处理的事件
        /// </summary>
        public event MSReceivedEventHandler OnMSReceived;

        /**//// <summary>
        /// 消息发出后的事件
        /// </summary>
        public event MSSendedEventHandler OnMSSended;

        /**//// <summary>
        /// 创建消息类
        /// </summary>
        /// <param name="queuePath">消息路径</param>
        /// <param name="timeoutSeconds">消息等待时间</param>
        /// <param name="formatter">消息格式</param>
        public MSQueue(string queuePath, int timeoutSeconds, IMessageFormatter formatter)
        {
            if (MessageQueue.Exists(queuePath))
            {
                this.queue = new MessageQueue(queuePath);
            }
            else
            {
                this.queue = MessageQueue.Create(queuePath);
            }
            this.timeout = TimeSpan.FromSeconds(Convert.ToDouble(timeoutSeconds));

            queue.Formatter = formatter;

            // Performance optimization since we don't need these features
            queue.DefaultPropertiesToSend.AttachSenderId = false;
            queue.DefaultPropertiesToSend.UseAuthentication = false;
            queue.DefaultPropertiesToSend.UseEncryption = false;
            queue.DefaultPropertiesToSend.AcknowledgeType = AcknowledgeTypes.None;
            queue.DefaultPropertiesToSend.UseJournalQueue = false;
        }

        /**//// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="messageObj">消息内容</param>
        /// <param name="lable">标签</param>
        public void Send(object messageObj, string lable)
        {
            Message m = new Message(messageObj, this.queue.Formatter);
            m.Label = lable;
            this.queue.Send(m);
            if (this.OnMSSended != null)
            {
                this.OnMSSended(this, new MSSendedEventArgs(messageObj));
            }
        }

        /**//// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="messageObj">消息内容</param>
        public void Send(object messageObj)
        {
            Message m = new Message(messageObj, this.queue.Formatter);
            this.queue.Send(m);
            if (this.OnMSSended != null)
            {
                this.OnMSSended(this, new MSSendedEventArgs(messageObj));
            }
        }

        /**//// <summary>
        /// 同步接受消息
        /// </summary>
        public void Receive()
        {
            Message m = this.queue.Receive();
            if (this.OnMSReceived != null)
            {
                this.OnMSReceived(this, new MSReceiveEventArgs(m));
            }
        }

        /**//// <summary>
        /// 异步接受消息
        /// </summary>
        public void RecevieAsy()
        {
            this.queue.ReceiveCompleted += new ReceiveCompletedEventHandler(this.ReceivedAsyEvt); //事件
            this.queue.BeginReceive(); 
        }

        /**//// <summary>
        /// ReceiveCompleted事件的实现
        /// </summary>
        /// <param name="source"></param>
        /// <param name="asyncResult"></param>
        protected virtual void ReceivedAsyEvt(object source, ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                //异步接受消息
                Message m = this.queue.EndReceive(asyncResult.AsyncResult);

                //在此插入处理消息的代码 
                if (this.OnMSReceived != null)
                {
                    this.OnMSReceived(this, new MSReceiveEventArgs(m, this.isAsyContinue));
                }
            }
            catch (MessageQueueException)
            {
                //错误处理代码
            }
            finally
            {
                if (this.isAsyContinue)
                {
                    this.queue.BeginReceive();//接收下一次事件
                }
            }
        }
    }

同时我还写了个用于测试此MSMQ消息队列封装类的Demo, /Files/laiwen/MessageQueueProject.rar。
欢迎广大网友多提宝贵意见。

转载于:https://www.cnblogs.com/laiwen/archive/2006/12/21/599519.html