C# MessageQueue.BeginReceive方法代码示例

        private static void Main()
        {
            //var factory = new ConnectionFactory() { HostName = "localhost" };
            //using (var connection = factory.CreateConnection())
            //using (var channel = connection.CreateModel())
            //{
            //    channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: false, arguments: null);

            //    var consumer = new EventingBasicConsumer(channel);
            //    consumer.Received += (model, ea) =>
            //    {
            //        var body = ea.Body;
            //        var message = Encoding.UTF8.GetString(body);
            //        Console.WriteLine(" [x] Received {0}", message);
            //    };
            //    channel.BasicConsume(queue: "hello", noAck: true, consumer: consumer);

            //    Console.WriteLine(" Press [enter] to exit.");
            //    Console.ReadLine();
            //}

            //while (true)
            //{
            try
            {
                var queue = new MessageQueue(@".\Private$\HelloWorld")
                {
                    Formatter = new XmlMessageFormatter(new[] { "".GetType() })
                };

                queue.ReceiveCompleted += (sender, e) =>
                {
                    var msg = queue.EndReceive(e.AsyncResult);
                    Console.WriteLine(msg.Body.ToString());
                    queue.BeginReceive();

                };

                queue.BeginReceive();

                //var message = queue.Receive(new TimeSpan(0, 0, 1));
                //message.Formatter = new XmlMessageFormatter(
                //                    new String[] { "System.String, mscorlib" });
                //Console.WriteLine(message.Body.ToString());
            }
            catch (Exception ex)
            {
                Console.WriteLine("No Message");
            }
            //Thread.Sleep(100);
            //}

            Console.WriteLine("Listening... Press any key to quit");
            Console.ReadLine();


        }

        public static void StartProcessing()
        {
            initializeSmtpClient();

            String queuePath = @".\private$\SendEmailQueue";

            new SendEmailQueueService().InsureQueueExsists(queuePath);
            msgQ = new MessageQueue(queuePath);
            msgQ.Formatter = new XmlMessageFormatter();

            /*
            The MessagePropertyFilter used by the queue to filter the set 
            of properties it receives or peeks for each message. 

            This filter is a set of Boolean values restricting the message
            properties that the MessageQueue receives or peeks. When the MessageQueue
            receives or peeks a message from the server queue, it retrieves only those
            properties for which the MessageReadPropertyFilter value is true.

            https://msdn.microsoft.com/en-us/library/system.messaging.messagequeue.messagereadpropertyfilter(v=vs.110).aspx
            */
            msgQ.MessageReadPropertyFilter.SetAll();
            msgQ.ReceiveCompleted += new ReceiveCompletedEventHandler(msgQ_RecieveCompleted);
            msgQ.BeginReceive();
        }

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

        protected override void OnStart(string[] args)
        {
            try
            {
                string queueName = ConfigurationManager.AppSettings["ProvisionQueueName"];
                //if (!MessageQueue.Exists(queueName))MessageQueue.Create(queueName, true);
                var queue = new MessageQueue(queueName);
                Trace.WriteLine("Queue Created in MSMQService at:" + DateTime.Now);
                //Console.ReadLine();
                queue.Formatter = new XmlMessageFormatter(new Type[] { typeof(String) });
                //Below code reads from queue once

                Message[] messages = queue.GetAllMessages();
                Trace.WriteLine("Reading from queue in MSMQService : " + queueName);
                Trace.WriteLine("Number of messages in MSMQService: " + messages.Length);
                /**foreach (Message msg in messages)
                {
                   // var decoded = JsonConvert.DeserializeObject(msg.Body.ToString());
                    Console.WriteLine("message:" + msg.Body);
                    Console.ReadLine();
                }
                Console.WriteLine("End of messages");
                Console.ReadLine();
                **/
                //Below code keeps reading from queue
                queue.ReceiveCompleted += QueueMessageReceived;
                queue.BeginReceive();
                signal.WaitOne();
                //Console.ReadLine();
            }
            catch (Exception e)
            {
                Trace.WriteLine("Error in receiving in MSMQService: " + e.Message);
            }
        }

 public void ReceiveAsync()
 {
     if (!MessageQueue.Exists(path)) { throw new Exception("queue does't exist!"); }
     System.Messaging.MessageQueue queue2 = new System.Messaging.MessageQueue(path);
     queue2.ReceiveCompleted += new ReceiveCompletedEventHandler(queue2_ReceiveCompleted);
     queue2.BeginReceive();
 }

      public void Start() 
      {
          //读取远程队列名称
          FileSyncMQ = ConfigurationManager.AppSettings["FileSyncMQ"];
          logger.Debug("远程队列名 " + FileSyncMQ);
          MAX_WORKER_THREADS = Convert.ToInt32(ConfigurationManager.AppSettings["MAX_WORKER_THREADS"].ToString());
          logger.Debug("异步读取工作线程数 " + MAX_WORKER_THREADS);
          try
          {
         
              
           q = new MessageQueue(FileSyncMQ);


          q.ReceiveCompleted += q_ReceiveCompleted;
            
            //异步方式，并发
            
            for(int i=0; i<MAX_WORKER_THREADS; i++)
            {
               
                waitHandleArray.Add( q.BeginReceive(MessageQueue.InfiniteTimeout).AsyncWaitHandle);
            }
               }
              catch (Exception ex)
              {
                  
                  logger.Error(ex);
              }
      }

        public void ReadGameServerInputQueue()
        {
            MessageQueue mq = new MessageQueue(".\\Private$\\Finvaders.ServerInputs");

            mq.BeginReceive(new TimeSpan(0, 4, 0), mq, MessageHandler);

            ServerInputQueue = mq;
        }

 public Replier(string requestQueueName,string invalidQueueName)
 {
     MessageQueue requestQueue = new MessageQueue(requestQueueName);
     invalidQueue = new MessageQueue(invalidQueueName);
     requestQueue.MessageReadPropertyFilter.SetAll();
     ((XmlMessageFormatter)requestQueue.Formatter).TargetTypeNames = new string[] { "System.String,mscorlib"};
     requestQueue.ReceiveCompleted += requestQueue_ReceiveCompleted;
     requestQueue.BeginReceive();
 }

 public static void StartProcessing()
 {
     string path = @".\private$\testqueue";
     ReadyQueue(path);
     _q = new MessageQueue(path);
     _q.Formatter = new XmlMessageFormatter(new Type[] { typeof(Email) });
     _q.MessageReadPropertyFilter.Body = true;
     _q.ReceiveCompleted += new ReceiveCompletedEventHandler(q_ReceiveCompleted);
     _q.BeginReceive();
 }

        public SimpleRouter(MessageQueue inQueue,
            MessageQueue outQueue1, MessageQueue outQueue2)
        {
            this.inQueue = inQueue;
            this.outQueue1 = outQueue1;
            this.outQueue2 = outQueue2;

            inQueue.ReceiveCompleted += OnMessage;
            inQueue.BeginReceive();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MsmqEventConsumer"/> class.
        /// </summary>
        /// <param name="mqPath">The mq path.</param>
        public MsmqEventConsumer(string mqPath)
        {
            if (!MessageQueue.Exists(mqPath)) {
                throw new ArgumentException("invalid msmq path", "mqPath");
            }

            _messageQueue = new MessageQueue(mqPath);
            _messageQueue.Formatter = new BinaryMessageFormatter();
            _messageQueue.ReceiveCompleted += FinishReceive;
            _messageQueue.BeginReceive();
        }

        public Replier(string requestQueueName, string invalidQueueName)
        {
            _requestQueue = QueueFactory.Get(requestQueueName);
            _invalidQueue = QueueFactory.Get(invalidQueueName);

            _requestQueue.MessageReadPropertyFilter.SetAll();
            ((XmlMessageFormatter)_requestQueue.Formatter).TargetTypeNames = new string[] { "System.String,mscorlib" };

            _requestQueue.ReceiveCompleted += OnReceiveCompleted;
            _requestQueue.BeginReceive();
        }

        public GestionReservation()
        {
            System.Diagnostics.Debug.WriteLine("(Info) Lancement du service de Gestion des reservations.");
            // Créé la queue de messages et son formateur.
            MessageQueue myQueue = new MessageQueue(QueuePath);
            myQueue.Formatter = new XmlMessageFormatter(new Type[] { typeof(ProjetNet.Modele.ModeleReservation.ReservationHotelVol) });

            // Ajoute l'evenement de reception d'un message.
            myQueue.ReceiveCompleted += new ReceiveCompletedEventHandler(MyPeekCompleted);

            // Lance l'attente asynchrone d'un message.
            myQueue.BeginReceive();
        }

        void replyQueue_ReceiveCompleted(object sender, ReceiveCompletedEventArgs e)
        {
            replyQueue = (MessageQueue)sender;
            Message replyMessage = replyQueue.EndReceive(e.AsyncResult);

             Console.WriteLine("Received reply");
            Console.WriteLine("\tTime:          {0}", DateTime.Now.ToString("HH:mm:ss.ffffff"));
            Console.WriteLine("\tMessage ID:    {0}", replyMessage.Id);
            Console.WriteLine("\tCorrel:        {0}", replyMessage.CorrelationId);
            Console.WriteLine("\tReply To   :   {0}", "<n/a>");
            Console.WriteLine("\tContents:       {0}", replyMessage.Body.ToString());
            replyQueue.BeginReceive();
        }

        public void Start()
        {
            if (!MessageQueue.Exists(QueueName))
            {
                MessageQueue.Create(QueueName);
            }

            try
            {
                if (MessageQueue.Exists(QueueName))
                {
                    _listeningQueue = new MessageQueue(QueueName);
                    _listeningQueue.ReceiveCompleted += (sender, args) =>
                    {
                        args.Message.Formatter = new XmlMessageFormatter(
                            new[] { typeof(string) });
                        var msg = args.Message.Body.ToString();

                        Console.WriteLine("Message received:{0}", msg);

                        var parts = msg.Split('|');
                        var json = parts[0];
                        var typeName = parts[1];
                        var type = Type.GetType(typeName);
                        var evt = (Event)JsonConvert.DeserializeObject(json, type);

                        new Denormaliser().StoreEvent(evt);

                        _listeningQueue.BeginReceive();
                    };

                    _listeningQueue.BeginReceive();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(string.Format("Unable to initialise message queue on your local machine.\r\n\r\n{0}", e));
            }
        }