C# MessageQueue.Close方法代码示例

        public void SendMessageToQueue(string queueName, CallDisposition data)
        {
            var msMq = new MessageQueue(queueName);
            var myMessage = new System.Messaging.Message();
            myMessage.Formatter = new XmlMessageFormatter(new Type[] { typeof(CallDisposition) });
            myMessage.Body = data;
            myMessage.Label = "MessageQueue";
            
            myMessage.UseJournalQueue = true;
            myMessage.Recoverable = true;

            //message send acknowledgement. 
            myMessage.AdministrationQueue = new MessageQueue(@".\Private$\MessageAcknowledgeQueue");
            myMessage.AcknowledgeType = AcknowledgeTypes.PositiveReceive | AcknowledgeTypes.PositiveArrival;

            try
            {
                msMq.Send(myMessage);
                Console.WriteLine("Message sent successfully!");

            }
            catch (MessageQueueException e)
            {
                Console.Write(e.ToString());
            }
            catch (Exception e)
            {
                Console.Write(e.ToString());
            }
            finally
            {
                msMq.Close();
            }
        }

        public void DeleteMessage(ref GlobalVariables oVar, string FormatType, string MSMQServer, string QueueName, string MessageId,string MessageLabel)
        {
            string MQPath = FormatType + MSMQServer + "\\" + QueueName;
            try
            {
                MessageQueue oMQueue = new MessageQueue(MQPath);
                try
                {

                    oMQueue.ReceiveById(MessageId);
                    oVar.sStatusMessage = " Message succesfully deleted";
                    //MessageBox.Show(MessageLabel + " Message succesfully deleted",
                     //       "Message Queuing Admin", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message,
                        "Message Queuing Admin", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    //MessageBox.Show(ex + "Queue Name is not valid or exist");
                    oVar.sStatusMessage = ex.Message;
                }
                oMQueue.Close();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message,
                    "Message Queuing Admin", MessageBoxButtons.OK, MessageBoxIcon.Information);
                oVar.sStatusMessage = ex.Message;
            }
        }

        public void LogTwoMessagesToQueueAndBeAbleToReadBothOfThem()
        {
            string path = @"FormatName:DIRECT=OS:" + CommonUtil.MessageQueuePath;

            MsmqSinkData sinkParams = new MsmqSinkData();
            sinkParams.QueuePath = path;

            MsmqSink sink = new MsmqSink();
            sink.Initialize(new TestLogSinkConfigurationView(sinkParams));

            CommonUtil.SendTestMessage(sink);

            using (MessageQueue mq = new MessageQueue(path))
            {
                Message msg = mq.Receive(new TimeSpan(0, 0, 1));
                mq.Close();
                msg.Formatter = new XmlMessageFormatter(new string[] {"System.String,mscorlib"});
                Assert.AreEqual(CommonUtil.FormattedMessage, msg.Body.ToString());
            }

            CommonUtil.SendTestMessage(sink);
            using (MessageQueue mq = new MessageQueue(path))
            {
                Message msg = mq.Receive(new TimeSpan(0, 0, 1));
                mq.Close();
                msg.Formatter = new XmlMessageFormatter(new string[] {"System.String,mscorlib"});
                Assert.AreEqual(CommonUtil.FormattedMessage, msg.Body.ToString());
            }
        }

 public bool addReservation(DemandeReservation reservation)
 {
     MessageQueue queue = new MessageQueue(FlyHotelConstant.ADRESSE_QUEUE);
     queue.Send(reservation);
     queue.Close();
     return true;
 }

        static void Run()
        {
            MessageQueue queue = null;
            MessageQueueTransaction trans = null;
            try
            {
                queue = new MessageQueue();
                queue.Path = Constants.QUEUE_PATH;
                queue.DefaultPropertiesToSend.Recoverable = true;

                trans = new MessageQueueTransaction();
                trans.Begin();

                MyOrder order = new MyOrder();
                order.ID = DateTime.Now.Ticks.ToString();
                order.Name = "Order_" + order.ID;

                Message msg = new Message(order);

                queue.Send(msg, trans);
                trans.Commit();
            }
            catch (Exception ex)
            {
                trans.Abort();
            }
            finally
            {
                queue.Close();
            }

            Console.WriteLine("message sent..");
        }

        static void Example2()
        {
            Console.WriteLine("Example2");
            MessageQueue queue = new MessageQueue(privateQueueName);

            queue.Send("Hello!");
            queue.Close();

            Console.WriteLine("End");
            Console.WriteLine();
        }

 public static void ClearMessageQueue(string queue)
 {
     string mqName = CreateMessageQueueName(queue);
     if (!MessageQueue.Exists(mqName))
         MessageQueue.Create(mqName, true);
     else
     {
         using (MessageQueue mq = new MessageQueue(mqName, false, false, QueueAccessMode.SendAndReceive))
         {
             mq.Purge();
             mq.Close();
         }
     }
 }

        static void Main(string[] args)
        {
            _mq = new MessageQueue(@".\private$\RequestQFileProcess", QueueAccessMode.Receive);
            _mq.ReceiveCompleted += new ReceiveCompletedEventHandler(_mq_ReceiveCompleted);
            _mq.Formatter = new ActiveXMessageFormatter();
            MessagePropertyFilter filter = new MessagePropertyFilter();
            filter.Label = true;
            filter.Body = true;
            filter.AppSpecific = true;
            _mq.MessageReadPropertyFilter = filter;
            DoReceive();

            Console.ReadLine();
            _mq.Close();
        }

        private void btnLire_Click(object sender, EventArgs e)
        {
            MessageQueue mqVols = new MessageQueue(@".\private$\cmdvols");
            MessageQueue mqHotels = new MessageQueue(@".\private$\cmdhotels");
            mqVols.Formatter = new XmlMessageFormatter(new Type[] { typeof(clsVolEntity) });
            mqHotels.Formatter = new XmlMessageFormatter(new Type[] { typeof(clsHotelEntity) });
            var messageVol = (clsVolEntity)mqVols.Peek().Body;
            var messageHotel = (clsHotelEntity)mqHotels.Peek().Body;

            clsVolEntity vol = new clsVolEntity();
            vol.dateDepart = messageVol.dateDepart;
            vol.villeDepart = messageVol.villeDepart;
            vol.paysDepart = messageVol.paysDepart;
            vol.villeDestination = messageVol.villeDestination;
            vol.paysDestination = messageVol.paysDestination;
            vol.prixVol = messageVol.prixVol;
            vol.infoClient = messageVol.infoClient;

            clsHotelEntity hotel = new clsHotelEntity();
            hotel.nomHotel = messageHotel.nomHotel;
            hotel.adresseHotel = messageHotel.adresseHotel;
            hotel.cpHotel = messageHotel.cpHotel;
            hotel.villeHotel = messageHotel.villeHotel;
            hotel.paysHotel = messageHotel.paysHotel;
            hotel.dateArrivee = messageHotel.dateArrivee;
            hotel.duree = messageHotel.duree;
            hotel.infoClient = messageHotel.infoClient;

            clsInfoClient client = vol.infoClient;

            // Enregistrement en mode transactionnel
            bool resEnregistrement = new TraitementCommandeLibrary.libTraitementCommande().ajouterCommande(hotel, vol, client);

            // Transaction OK
            if (resEnregistrement == true)
            {
                txtListe.AppendText("Enregistrement du vol " + vol.villeDepart + " - " + vol.villeDestination + " et l'hotel " + hotel.nomHotel);
                mqVols.Receive();
                mqHotels.Receive();
            }
            // Transaction KO
            else
            {
                txtListe.AppendText("Impossible d'enregsitrer le vol " + vol.villeDepart + " - " + vol.villeDestination + " et l'hotel " + hotel.nomHotel);
            }
            mqVols.Close();
            mqHotels.Close();
        }

 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;
     }
 }

        public static void ClearQueue(string sQueue)
        {
            MessageQueue oQueue;

            try
            {

                if (!MessageQueue.Exists(sQueue)) { MessageQueue.Create(sQueue); }

                oQueue = new MessageQueue(sQueue);

                oQueue.Purge();
                oQueue.Close();
            }
            catch (Exception e) { Console.WriteLine(e.Message); }
        }

 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 void EnviarMensaje(object mensaje, string id,
            string nombreColaRequest, string nombreColaResponse)
        {
            MessageQueue colaRequest = new MessageQueue(PRIVATE_QUEQUE + nombreColaRequest);
            EstablecerFormateador(colaRequest);
            Message Msg = new Message(mensaje)
                              {
                                  ResponseQueue = new MessageQueue(PRIVATE_QUEQUE + nombreColaResponse)
                              };

            EstablecerFormateador(Msg.ResponseQueue);

            Msg.Label = id;
            colaRequest.Send(Msg);
            colaRequest.Close();
        }

 public static bool SendImpression(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 true;
     }
     catch
     {
         return false;
     }
 }

        public static void Main(string[] args)
        {
            mongoDBWriter = new MongoDBWriter();
            logQueue = new MessageQueue(@".\private$\loggingMongoDBQueue", QueueAccessMode.Receive);
            logQueue.ReceiveCompleted += MessageQueueReceiveCompleted;
            //we just want to pass around json strings, so we don't care about the contract
            logQueue.Formatter = new XmlMessageFormatter(){TargetTypes = new []{typeof(string)}};

            var filter = new MessagePropertyFilter {Label = true, Body = true, AppSpecific = true};
            logQueue.MessageReadPropertyFilter = filter;

            DoReceive();

            Console.WriteLine("Application running and processing queue. Press any key to quit.");
            Console.ReadLine();
            logQueue.Close();
        }