消息队列的使用

 

换了新公司，有了新的开始。

现在开始用消息队列，做邮件的异步发送。

本系统，通过webservice访问本地消息队列，没有用wcf的消息队列访问，也没有用公共队列。

不过由于有webservice的支持，访问本地消息队列，没有任何的问题。

以下为队列操作代码

 

  ///   <summary>
     ///  队列操作类
     ///   </summary>
    public    class  OperateQueue:Interface.IStore
    {
        ///   <summary>
        ///  建立队列
        ///   </summary>
        ///   <param name="queueName"> 队列名称 </param>
        ///   <returns> 是否成功 </returns>
        private   ResultInfo < bool >  CreateQueue( string  queueName)
       {
           ResultInfo < bool >  result  =   new  ResultInfo < bool > ();
           result.Data  =   false ;
           result.Result  =   false ;

            try
           {
              MessageQueue.Create(queueName,  true );
              result.Data  =   true ;
              result.Result  =   true ;
           }
            catch (Exception ex)
           {
                throw  ex;
           }

            return  result;
       }

        ///   <summary>
        ///  判断队列是否存在
        ///   </summary>
        ///   <param name="queueName"> 队列名字 </param>
        ///   <returns></returns>
        private    bool  IsQueueExists( string  queueName)
       {
            return  MessageQueue.Exists(queueName);
       }

        ///   <summary>
        ///  发送消息
        ///   </summary>
        ///   <param name="queueName"> 队列名称 </param>
        ///   <returns> 是否成功 </returns>
        public  ResultInfo < bool >  StoreMessage( string  queueName,  string  message)
       {
            if  ( ! this .IsQueueExists(queueName))
           {
                this .CreateQueue(queueName);
           }

           MessageQueue queue  =   new  MessageQueue() ;
           ResultInfo < bool >  result  =   new  ResultInfo < bool > ();
           result.Data  =   false ;
           result.Result  =   false ;

           MessageQueueTransaction mts  =   new  MessageQueueTransaction();
           
            try
           {
               mts.Begin();

               queue =   new  MessageQueue(queueName);

               queue.Send(message,mts);

               result.Data  =   true ;
               result.Message  =   " 消息存储成功 " ;
               result.Result  =   true ;

               mts.Commit();
           }
            catch  (Exception ex)
           {
               mts.Abort();
                throw  ex;
           }
            finally
           {
               queue.Close();
               queue.Dispose();
           }

            return  result;
       }

        ///   <summary>
        ///  读取消息
        ///   </summary>
        ///   <param name="queueName"> 队列名称 </param>
        ///   <returns> 读取到的消息 </returns>
        public   ResultInfo < string >  ReadMessage( string  queueName)
       {
           ResultInfo < string >  result  =   new  ResultInfo < string > ();
           result.Data  =   string .Empty;
           result.Result  =   false ;

           MessageQueue queue  =   new  MessageQueue();

            try
           {
               queue  =   new  MessageQueue(queueName);
               Message message  =   new  Message();
               
               message  =  queue.Receive();
               message.Formatter  =   new  System.Messaging.XmlMessageFormatter( new  Type[] {  typeof ( string ) });

               result.Data  =  message.Body.ToString();
               result.Result  =   true ;
           }
            catch (Exception ex)
           {
               result.Message  =  ex.Message;   
           }
            finally
           {
               queue.Close();
               queue.Dispose();
           }

            return  result;
       }
    }

 

采用了队列的事务操作，istore用来与上层调用进行隔离，这样做是为了保证，当需要使用其它消息队列时，做到最小改动。

webservice和队列部署在同一台服务器上，本打算利用

  System.Messaging.MessageQueue queue = new System.Messaging.MessageQueue(@"FormatName:DIRECT=tcp:192.168.16.85\private$\Action");

去进行局域网内的访问，但是没有成功，所以暂时放弃。

转载于:https://www.cnblogs.com/chenleinet/archive/2011/07/19/2110587.html