C# MessageQueue.Dispose方法代码示例

        public void WriteReadMessage()
        {
            var ids = new List<string>();
            var mq = new MessageQueue(@".\private$\QMM_");

            
            mq.Send("12345");
            mq.Send("23456");

            var msg = mq.Receive(new TimeSpan(0, 0, 0, 0, 1));
            if (msg != null)
                Console.WriteLine(msg.Body);

            mq.Dispose();
            mq = null;

            mq = new MessageQueue(@".\private$\QMM_");
            
            msg = mq.Receive(new TimeSpan(0, 0, 0, 0, 1));
            if (msg != null)
            {
                msg.Formatter = new XmlMessageFormatter(new Type[] {typeof (string)});
                Console.WriteLine(msg.Body);
            }
        }

        public static void HandleError(MsmqPoisonMessageException error)
        {
            ProcessorQueue processorQueue = (ProcessorQueue)error.Data["processorQueue"];
            MessageQueue poisonQueue = new System.Messaging.MessageQueue(processorQueue.PoisonQueue);
            MessageQueue errorQueue = new System.Messaging.MessageQueue(processorQueue.ErrorQueue);

            using (TransactionScope txScope = new TransactionScope(TransactionScopeOption.RequiresNew))
            {
                try
                {
                    // Send the message to the poison and error message queues.
                    poisonQueue.Send((IWorkflowMessage)error.Data["message"], MessageQueueTransactionType.Automatic);
                    errorQueue.Send((WorkflowErrorMessage)error.Data["errorMessage"], MessageQueueTransactionType.Automatic);
                    txScope.Complete();
                }
                catch (InvalidOperationException)
                {

                }
                finally
                {
                    poisonQueue.Dispose();
                    errorQueue.Dispose();
                }
            }
        }

        public void StringMessageFormatter()
        {
            var ids = new List<string>();
            var mq = new MessageQueue(@".\private$\QMM_");

            mq.Formatter = new StringMessageFormatter();
            mq.Send("12345");
            mq.Send("23456");

            mq.Dispose();
            mq = null;

            mq = new MessageQueue(@".\private$\QMM_");

            for (int i = 0; i < 3; i++)
            {
                Message msg = null;
                try
                {
                    msg = mq.Receive(new TimeSpan(0, 0, 0, 0, 1));
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }

                if (msg != null)
                {
                    msg.Formatter = new StringMessageFormatter();
                    Console.WriteLine(msg.Body);
                }
            }
        }

        public static MsmqConnector OpenReceive(MsmqAddress address, bool enlist)
        {
            var queue = new MessageQueue(address.Proprietary, QueueAccessMode.Receive);
            queue.MessageReadPropertyFilter.SetAll();

            Log.Info(Diagnostics.OpeningQueueForReceive, address, enlist);

            if (!enlist || queue.Transactional)
                return new MsmqConnector(queue, address, enlist);

            queue.Dispose();
            Log.Error(Diagnostics.NonTransactionalQueue, address.Canonical);
            throw new EndpointException(string.Format(CultureInfo.InvariantCulture, Diagnostics.NonTransactionalQueue, address.Canonical));
        }

 internal static bool SendImpression2(int IDSubScheduleDetail)
 {
     try
     {
         MessageQueue MQ = new MessageQueue(server_msmq2);
         MQ.Send(string.Format("IDSub:{0}:{1:dd/MM/yyyy HH-mm}", IDSubScheduleDetail, DateTime.Now),
             string.Format("IDSub:{0}:{1:dd/MM/yyyy HH-mm}", IDSubScheduleDetail, DateTime.Now));
         MQ.Dispose();
         return true;
     }
     catch
     {
         return false;
     }
 }

 public static bool SendClick(string IDSubScheduleDetail, string IDSubpage)
 {
     try
     {
         MessageQueue MQ = new MessageQueue(MQ_CLICK);
         MQ.Send(string.Format("IDSub:{0},{1}:{2:dd/MM/yyyy HH-mm}", IDSubScheduleDetail, IDSubpage, DateTime.Now),
             string.Format("IDSub:{0},{1}:{2:dd/MM/yyyy HH-mm}", IDSubScheduleDetail, IDSubpage, DateTime.Now));
         MQ.Dispose();
         MQ.Close();
         return true;
     }
     catch
     {
         return false;
     }
 }

 public static string SendImpression3(int IDSubScheduleDetail)
 {
     try
     {
         MessageQueue MQ = new MessageQueue(server_msmq);
         MQ.Send(string.Format("IDSub:{0}:{1:dd/MM/yyyy HH-mm}", IDSubScheduleDetail, DateTime.Now),
             string.Format("IDSub:{0}:{1:dd/MM/yyyy HH-mm}", IDSubScheduleDetail, DateTime.Now));
         MQ.Dispose();
         MQ.Close();
         return "done";
     }
     catch(Exception ex)
     {
         return ex.Message;
     }
 }

        private void button1_Click(object sender, EventArgs e)
        {
            MessageQueue msgQ = new MessageQueue(_msgQRec);

           

            System.Messaging.Message m = new System.Messaging.Message();
            m.Formatter = new XmlMessageFormatter(new Type[] { typeof(String) });

            try
            {
                //When we pull the message off from the queue it will be in the form of a 
                //byte array
                m = msgQ.Receive();
                byte[] data = new byte[1024];
                m.BodyStream.Read(data, 0, 1024);
                string strMessage = ASCIIEncoding.ASCII.GetString(data);
                
                //load message into XmlDocument
                XmlDocument xml = new XmlDocument();
                xml.LoadXml(strMessage);
             
                //Deserialize Xml Document into a typed C# object  
                var ser = new XmlSerializer(typeof(WorkOrderRequests));
                var wo = (WorkOrderRequests)ser.Deserialize(new StringReader(xml.OuterXml));
               
                //Populate our GUI
                txtFunctionalLocation.Text = wo.WorkOrderRequest[0].FunctionalLocation;
                txtMachineID.Text = wo.WorkOrderRequest[0].MachinedID;
                txtMaintenanceType.Text = wo.WorkOrderRequest[0].MaintenanceType;
                txtPlant.Text = wo.WorkOrderRequest[0].Plant;
                txtRequestedDate.Text = wo.WorkOrderRequest[0].RequestDate.ToString();
                txtWorkOrderID.Text = wo.WorkOrderRequest[0].WorkOrderID;

                btnCompleteWorkOrder.Visible = true;

                msgQ.Close();
                msgQ.Dispose();  
              
            }
            catch (Exception ex)
            {
                MessageBox.Show(String.Format("An exception has occurred {0}", ex.ToString()));
            }

        }

        public static void HandleComplete(ProcessorQueue processorQueue, IWorkflowMessage message)
        {
            MessageQueue completedQueue = new System.Messaging.MessageQueue(processorQueue.CompletedQueue);

            using (TransactionScope txScope = new TransactionScope(TransactionScopeOption.RequiresNew))
            {
                try
                {
                    completedQueue.Send(message, MessageQueueTransactionType.Automatic);
                    txScope.Complete();
                }
                catch (InvalidOperationException)
                {

                }
                finally
                {
                    completedQueue.Dispose();
                }
            }
        }

 /// <summary>
 /// Closes the queue handle.  Cancel pending receive operation by closing the queue handle
 /// To properly dispose of the queue handle, ensure that EnableConnectionCache=false on the
 /// MessageQueue that this listener is configured to use.
 /// </summary>
 protected void CloseQueueHandle(MessageQueue mq)
 {
     lock (messageQueueMonitor)
     {
         mq.Close();
         mq.Dispose();
     }
 }

        // Sends status message to status queue.
        // 0 - subqueue complete, 1 - subqueue ready for delete
        private void SendToStatusQueue(string correlationId, int subQueueStatus, string largeSequenceId)
        {
            string statusQueuePath = "FormatName:DIRECT=OS:" + this.queue.MachineName + @"\" + Parameters.STATUS_QUEUE;
            MessageQueue statusQueue = new MessageQueue(statusQueuePath);
            try
            {
                bool canRead = statusQueue.CanRead;
                bool canWrite = statusQueue.CanWrite;
                if ((!canRead) || (!canWrite))
                {
                    throw new LargeMessageQueueException(null,
                        "Transactional status queue should have both read and write access for this user. Current status is: Read=" +
                        canRead + ", Write=" + canWrite);
                }
            }
            catch (MessageQueueException mqe)
            {
                throw new LargeMessageQueueException("Transactional status queue not available", mqe);
            }

            Message statusMessage = new Message();
            statusMessage.AppSpecific = subQueueStatus;
            statusMessage.Formatter = new BinaryMessageFormatter();
            statusMessage.Body = largeSequenceId;
            if (correlationId != null)
            {
                statusMessage.CorrelationId = correlationId;
            }

            statusQueue.Send(statusMessage, MessageQueueTransactionType.Single);

            statusQueue.Dispose();
            statusQueue.Close();
        }

 /// <summary>
 /// Activates a subscription by starting
 /// to listen to the specified queue
 /// </summary>
 /// <param name="queue">Queue to activate</param>
 /// <param name="subscription">Subscription to activate</param>
 private void ActivateSubscription(MessageQueue queue, MsmqSubscription subscription)
 {
     try
      {
     _lock.AcquireWriterLock(Timeout.Infinite);
     _subscriptionsByID.Add(subscription.ID, subscription);
     // do we already have suscriptions to this queue?
     Receiver receiver = null;
     if ( !_queueReceivers.ContainsKey(queue.FormatName) )
     {
        receiver = new Receiver(queue, OnMessageReceived);
        _queueReceivers.Add(queue.FormatName, receiver);
     } else
     {
        receiver = _queueReceivers[queue.FormatName];
        receiver.AddRef();
        queue.Dispose();
     }
      } finally
      {
     _lock.ReleaseWriterLock();
      }
 }

 /// <summary>
 /// Add a job for the framework to process
 /// </summary>
 /// <param name="jobName">The name of the job in the framework's workflow file</param>
 /// <param name="message">A class containing the message data</param>
 public static void AddFrameworkJob(string jobName, IWorkflowMessage message)
 {
     // Add a message to the Queue
     ProcessorJob processorJob = new ProcessorJob() { JobName = jobName, CreatedDate = DateTime.Now };
     WorkflowConfiguration.LoadFrameworkConfig(processorJob);
     ProcessorQueue processorQueue = GetActiveQueue(processorJob, QueueOperationType.Delivery);
     MessageQueue workflowQueue = new MessageQueue(processorQueue.MessageQueue);
     MessageQueueTransaction transaction = new MessageQueueTransaction();
     try
     {
         if (processorQueue.MessageQueueType == MessageQueueType.Transactional)
         {
             transaction.Begin();
             workflowQueue.Send(message, jobName, transaction);
             transaction.Commit();
         }
         else
         {
             workflowQueue.Send(message, jobName);
         }
     }
     catch (Exception e)
     {
         if (processorQueue.MessageQueueType == MessageQueueType.Transactional &&
             transaction.Status == MessageQueueTransactionStatus.Pending)
             transaction.Abort();
         throw new WorkflowException("Error adding message to Queue", e);
     }
     finally
     {
         transaction.Dispose();
         workflowQueue.Dispose();
     }
 }

        // Missing fragments are marked as rejected in a separate transaction and are sent to sender's DLQ on commit.
        private void PerformHouseKeeping(string correlationId)
        {
            string subQueueName = Utilities.GetSubQueueName(correlationId);
            string subQueuePath = "FormatName:DIRECT=OS:" + this.queue.MachineName + @"\" + this.queue.QueueName + ";" + subQueueName;
            MessageQueue subQueue = new MessageQueue(subQueuePath);

            Message messageToReject = null;

            // MarkMessageRejected works only with transaction
            MessageQueueTransaction rejectTransaction = new MessageQueueTransaction();
            rejectTransaction.Begin();

            // ReceiveById to clear the first header fragment whose Id is put in all other fragment's correlation id
            // This is in a separate try-catch so that it proceeds with marking other fragments in case first fragment
            // is the one that is lost
            try
            {
                messageToReject = subQueue.ReceiveById(correlationId, rejectTransaction);
                NativeMethods.MarkMessageRejected(subQueue.FormatName, messageToReject.LookupId);
            }
            catch (MessageQueueException)
            {
                // Don't do anything
            }
            catch (InvalidOperationException)
            {
                // Don't do anything
            }

            // Marks other fragments in subqueue as rejected
            try
            {
                while (true)
                {
                    messageToReject = subQueue.ReceiveByCorrelationId(correlationId, rejectTransaction);
                    NativeMethods.MarkMessageRejected(subQueue.FormatName, messageToReject.LookupId);
                }
            }
            catch (MessageQueueException)
            {
                // Don't do anything and just come out of the loop
            }
            catch (InvalidOperationException)
            {
                // Don't do anything and just come out of the loop
            }

            // Safe reject in case message becomes available in main queue
            try
            {
                messageToReject = this.queue.ReceiveById(correlationId, rejectTransaction);
                NativeMethods.MarkMessageRejected(subQueue.FormatName, messageToReject.LookupId);
            }
            catch (MessageQueueException)
            {
                // Don't do anything
            }
            catch (InvalidOperationException)
            {
                // Don't do anything
            }

            // Mark other fragments in main queue as rejected
            try
            {
                while (true)
                {
                    messageToReject = this.queue.ReceiveByCorrelationId(correlationId, rejectTransaction);
                    NativeMethods.MarkMessageRejected(this.queue.FormatName, messageToReject.LookupId);
                }
            }
            catch (MessageQueueException)
            {
                // Don't do anything and just come out of the loop
            }
            catch (InvalidOperationException)
            {
                // Don't do anything and just come out of the loop
            }
            finally
            {
                subQueue.Dispose();
                subQueue.Close();

                rejectTransaction.Commit();
                rejectTransaction.Dispose();
            }
        }

        // Peeks message (first/application-specified correlationId) from status queue
        private Message PeekFromStatusQueue(string correlationId)
        {
            string statusQueuePath = "FormatName:DIRECT=OS:" + this.queue.MachineName + @"\" + Parameters.STATUS_QUEUE;
            MessageQueue statusQueue = new MessageQueue(statusQueuePath);
            statusQueue.Formatter = new BinaryMessageFormatter();
            statusQueue.MessageReadPropertyFilter.AppSpecific = true;
            statusQueue.MessageReadPropertyFilter.CorrelationId = true;

            Message statusMessage = null;
            try
            {
                if (correlationId == null)
                {
                    statusMessage = statusQueue.PeekByLookupId(MessageLookupAction.First, 0);
                }
                else
                {
                    statusMessage = statusQueue.PeekByCorrelationId(correlationId, TimeSpan.Zero);
                }
            }
            catch (MessageQueueException)
            {
                // If status queue is empty, peek will throw MessageQueueException
                throw new InvalidOperationException();
            }

            statusQueue.Dispose();
            statusQueue.Close();
            return statusMessage;
        }