C# MessageQueue.Purge方法代码示例

        public static void StartMSMQService()
        {
            msMqRequestDelete = new MessageQueue("FormatName:Direct=OS:" + Environment.MachineName.ToLower() + "\\private$\\requestdeletequeue");
            if (System.Messaging.MessageQueue.Exists(".\\private$\\requestdeletequeue"))
            {
                msMqRequestDelete.Purge();
                if (msMqRequestDelete != null)
                {
                    msMqRequestDelete.BeginReceive();
                }
                msMqRequestDelete.ReceiveCompleted += new ReceiveCompletedEventHandler(mq_ReceiveCompletedRequestTaskKill);
            }
            else
            {
                msMqRequestDelete = System.Messaging.MessageQueue.Create(".\\private$\\requestdeletequeue", true);
            }


            msMqReply = new MessageQueue("FormatName:Direct=OS:" + Environment.MachineName.ToLower() + "\\private$\\requestqueue");
            if (System.Messaging.MessageQueue.Exists(".\\private$\\requestqueue"))
            {
                {
                    msMqReply.Purge();
                    if (msMqReply != null)
                    {
                        msMqReply.BeginReceive();
                    }
                    msMqReply.ReceiveCompleted += new ReceiveCompletedEventHandler(mq_ReceiveCompletedReply);
                }
            }
            else
            {
                msMqReply = System.Messaging.MessageQueue.Create(".\\private$\\requestqueue", true);
            }
        }

		public void Purge()
		{
			using (var queue = new MessageQueue(_address.LocalName, QueueAccessMode.ReceiveAndAdmin))
			{
				queue.Purge();
			}
		}

        public MsmqReceiver()
        {
            if (!Address.Local.Machine.Equals(RuntimeEnvironment.MachineName, StringComparison.OrdinalIgnoreCase))
            {
                throw new InvalidOperationException(String.Format("Input queue [{0}] must be on the same machine as this process [{1}].", Address.Local, RuntimeEnvironment.MachineName));
            }

            queue = new MessageQueue(MsmqUtilities.GetFullPath(Address.Local), false, true, QueueAccessMode.Receive);

            var messageReadPropertyFilter = new MessagePropertyFilter
            {
                Body = true,
                TimeToBeReceived = true,
                Recoverable = true,
                Id = true,
                ResponseQueue = true,
                CorrelationId = true,
                Extension = true,
                AppSpecific = true
            };

            queue.MessageReadPropertyFilter = messageReadPropertyFilter;

            if (PurgeOnStartup)
            {
                queue.Purge();
            }
        }

 private static void PurgeQueue(string queuePath)
 {
     using (var queue = new MessageQueue(queuePath))
     {
         queue.Purge();
     }
 }

        static void Main(string[] args)
        {
            string path = @".\private$\XactQueue4Demo";
            if(!MessageQueue.Exists(path))
            {
                MessageQueue.Create(path, true);
            }
            var queue = new MessageQueue(path);
            queue.Purge();

            using (ChannelFactory<IGreeting> channelFactoryHello = new ChannelFactory<IGreeting>("greetingService"))
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    IGreeting proxy = channelFactoryHello.CreateChannel();
                    proxy.SayHello("Foo");
                    proxy.SayGoodbye("Bar");
                    (proxy as ICommunicationObject).Close();
                    scope.Complete();
                }
            }
            var message = queue.Receive();
            byte[] buffer = new byte[message.BodyStream.Length];
            message.BodyStream.Read(buffer, 0, buffer.Length);
            Console.WriteLine(Encoding.Default.GetString(buffer));
        }

 private static void PurgeSubqueue(string queuePath, string subqueueName)
 {
     using (var queue = new MessageQueue(queuePath + ";" + subqueueName))
     {
         queue.Purge();
     }
 }

 public static void RecreateMessageQueue(string path, bool transactional)
 {
     bool defaultCacheEnabled = MessageQueue.EnableConnectionCache;
     MessageQueue.ClearConnectionCache();
     MessageQueue.EnableConnectionCache = false;
     if (MessageQueue.Exists(path))
     {
         // TODO (EE): delete/create doesn't work for some reason
         //                MessageQueue.Delete(path);
         //                queue = MessageQueue.Create(path, transactional);
         using (MessageQueue queue = new MessageQueue(path))
         {
             queue.Purge();
         }
     }
     else
     {
         /*
          * MSDN docs indicate that calls to the static .Create() method should include
          *   an explicit call to .Dispose() b/c unmanaged resources are involved
          * Here this req'ment is handled implicitly with the using() statement
          *  even though the empty using() block seems odd at first glance b/c it
          *  encloses a static method call
          */
         using (MessageQueue.Create(path, transactional))
         {
         	
         }
     }
     MessageQueue.ClearConnectionCache();
     MessageQueue.EnableConnectionCache = defaultCacheEnabled; // set to default
 }

        public Task Init(Func<MessageContext, Task> onMessage, Func<ErrorContext, Task<ErrorHandleResult>> onError, CriticalError criticalError, PushSettings settings)
        {
            peekCircuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker("MsmqPeek", TimeSpan.FromSeconds(30), ex => criticalError.Raise("Failed to peek " + settings.InputQueue, ex));
            receiveCircuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker("MsmqReceive", TimeSpan.FromSeconds(30), ex => criticalError.Raise("Failed to receive from " + settings.InputQueue, ex));

            var inputAddress = MsmqAddress.Parse(settings.InputQueue);
            var errorAddress = MsmqAddress.Parse(settings.ErrorQueue);

            if (!string.Equals(inputAddress.Machine, RuntimeEnvironment.MachineName, StringComparison.OrdinalIgnoreCase))
            {
                throw new Exception($"MSMQ Dequeuing can only run against the local machine. Invalid inputQueue name '{settings.InputQueue}'.");
            }

            inputQueue = new MessageQueue(inputAddress.FullPath, false, true, QueueAccessMode.Receive);
            errorQueue = new MessageQueue(errorAddress.FullPath, false, true, QueueAccessMode.Send);

            if (settings.RequiredTransactionMode != TransportTransactionMode.None && !QueueIsTransactional())
            {
                throw new ArgumentException($"Queue must be transactional if you configure the endpoint to be transactional ({settings.InputQueue}).");
            }

            inputQueue.MessageReadPropertyFilter = DefaultReadPropertyFilter;

            if (settings.PurgeOnStartup)
            {
                inputQueue.Purge();
            }

            receiveStrategy = receiveStrategyFactory(settings.RequiredTransactionMode);

            receiveStrategy.Init(inputQueue, errorQueue, onMessage, onError, criticalError);

            return TaskEx.CompletedTask;
        }

        /// <summary>
        /// 作者:Vincen
        /// 时间：2013.11.14 PM
        /// 描述：处理异常日志（消息队列）
        /// </summary>
        public static void DoExceptionLog()
        {
            InitQueue(MsmqType.ExceptionLog);

            using (var mq = new MessageQueue(MsmpPath + MsmqType.ExceptionLog))
            {
                var msgs = mq.GetAllMessages();
                foreach (var msg in msgs)
                {
                    try
                    {
                        msg.Formatter = new XmlMessageFormatter(new[] { typeof(ExceptionLogs) });
                        var item = msg.Body as ExceptionLogs;
                        if (null == item)
                        {
                            continue;
                        }
                        ExceptionLogsBLL.CreateExceptionLogs(item);
                    }
                    //记录下（异常）日志信息
                    catch (Exception e)
                    {
                        Common.MSMQ.QueueManager.AddExceptionLog(new ExceptionLogs()
                        {
                            ExceptionType = Utility.CommonHelper.To<int>(ExceptionType.Msmq),
                            Message = string.Format("MSMQ-DoExceptionLog：{0};{1};{2}", e.Message, e.InnerException.Message, e.HelpLink),
                            IsTreat = false,
                            CreateBy = 0,
                            CreateTime = DateTime.Now
                        });
                    }
                }
                mq.Purge();
            }
        }

 public void ClearMessage()
 {
     if (MessageQueue.Exists(QueuePath))
     {
         MessageQueue queue = new MessageQueue(QueuePath);
         queue.Purge();
     }
 }

 //
 // GET: /Payment/Purge/
 public ActionResult Purge() {
     if (MessageQueue.Exists(".\\Private$\\easyTravelPaymentQueue")) {
         using (MessageQueue mq = new MessageQueue(".\\Private$\\easyTravelPaymentQueue")) {
             mq.Purge();
         }
     } else {
         log.Warn("Can't empty non existing queue \".\\Private$\\easyTravelPaymentQueue\". Enable MSMQPaymentPlugin.net to have Queue created on payment.");
     }
     return RedirectToAction("Index");
 }

 public static void Reset()
 {
     if (!MessageQueue.Exists(Queue.Name))
         MessageQueue.Create(Queue.Name);
     else
     {
         var queue = new MessageQueue(Queue.Name);
         queue.Purge();
     }
 }

        /// <summary>
        /// Deletes all messages from the queue with the specified name
        /// </summary>
        /// <param name="queueName"></param>
        public static void PurgeQueue(string queueName)
        {
            var path = GetPath(queueName);

            if (!MessageQueue.Exists(path)) return;

            using (var messageQueue = new MessageQueue(path))
            {
                messageQueue.Purge();
            }
        }

        protected override void DoSetUp()
        {
            serializer = new JsonMessageSerializer();
            senderQueue = new MsmqMessageQueue(SenderQueueName);

            destinationQueue = NewRawMsmqQueue(DestinationQueueName);

            senderQueue.PurgeInputQueue();
            destinationQueue.Purge();

            TrackDisposable(senderQueue);
        }

        public MsmqBehaviorTests()
        {
            using (var subqueue = new MessageQueue(testQueuePath + ";errors"))
            {
                subqueue.Purge();
            }

            using (var subqueue = new MessageQueue(transactionalTestQueuePath + ";errors"))
            {
                subqueue.Purge();
            }
        }