C# MessageQueue.GetAllMessages方法代码示例

 static void Main(string[] args)
 {
     SolicitudServicioData oSolicitudServicioData = new SolicitudServicioData();
     string rutaCola = @".\private$\SolicitudServicioRecibida";
     if (MessageQueue.Exists(rutaCola) == true)
     {
         MessageQueue cola = new MessageQueue(rutaCola);
         Message[] msgs = cola.GetAllMessages();
         SolicitudServicioDTO oSolicitudServicioDTO = new SolicitudServicioDTO();
         if (cola.GetAllMessages().Count() > 0)
         {
             foreach (Message msg in cola.GetAllMessages())
             {
                 msg.Formatter = new XmlMessageFormatter(new Type[] { typeof(SolicitudServicioDTO) });
                 oSolicitudServicioDTO = (SolicitudServicioDTO)msg.Body;
                 if (oSolicitudServicioData.Get(oSolicitudServicioDTO.SolicitudServicioId) == null)
                 {
                     oSolicitudServicioData.Add(oSolicitudServicioDTO);
                 }
                 else
                 {
                     oSolicitudServicioData.Update(oSolicitudServicioDTO);
                 }
                 cola.Receive();
             }
         }
     }
 }

 private void recuperarFacturasToolStripMenuItem_Click(object sender, EventArgs e)
 {
     try
     {
         string rutaCola = @".\private$\facturas";
         if (!MessageQueue.Exists(rutaCola))
             MessageQueue.Create(rutaCola);
         MessageQueue cola = new MessageQueue(rutaCola);
         cola.Formatter = new XmlMessageFormatter(new Type[] { typeof(Factura) });
         int total = cola.GetAllMessages().Count();
         while (cola.GetAllMessages().Count() != 0)
         {
             System.Messaging.Message mensaje = cola.Receive();
             Factura facturaItem = (Factura)mensaje.Body;
             string postdata = "{\"Numero\":\"" + facturaItem.Numero + "\",\"Fecha\":\"" + facturaItem.Fecha + "\",\"Cliente\":\"" + facturaItem.Cliente + "\",\"ImporteBruto\":\"" + facturaItem.ImporteBruto + "\",\"ImporteVenta\":\"" + facturaItem.ImporteVenta + "\",\"ImporteIGV\":\"" + facturaItem.ImporteIGV + "\",\"ImporteTotalVenta\":\"" + facturaItem.ImporteTotalVenta + "\"}";
             byte[] data = Encoding.UTF8.GetBytes(postdata);
             HttpWebRequest req = (HttpWebRequest)WebRequest.Create("http://localhost:23440/Facturas.svc/Facturas");
             req.Method = "POST";
             req.ContentLength = data.Length;
             req.ContentType = "application/json";
             var reqStream = req.GetRequestStream();
             reqStream.Write(data, 0, data.Length);
             HttpWebResponse res = (HttpWebResponse)req.GetResponse();
             StreamReader reader = new StreamReader(res.GetResponseStream());
             string compraJson = reader.ReadToEnd();
             JavaScriptSerializer js = new JavaScriptSerializer();
         }
         MessageBox.Show(total + " facturas recuperadas", "Facturas Recuperadas");
     }
     catch {
         MessageBox.Show("Error de comunicación", "Error");            }
 }

        static void Main(string[] args)
        {
            CitaDAO dao = new CitaDAO();
            string rutaCola = @".\private$\CitaRecibida";
            if (MessageQueue.Exists(rutaCola) == true)
            {
                MessageQueue cola = new MessageQueue(rutaCola);
                Message[] msgs = cola.GetAllMessages();
                Cita _cita = new Cita();
                if (cola.GetAllMessages().Count() > 0)
                {
                    foreach (Message msg in cola.GetAllMessages())
                    {
                        msg.Formatter = new XmlMessageFormatter(new Type[] { typeof(Cita) });
                        _cita = (Cita)msg.Body;
                        if (dao.Obtener(_cita.IdCita) == null)
                        {
                            dao.Crear(_cita);
                        }
                        else
                        {
                            dao.Modificar(_cita);
                        }

                        cola.Receive();
                    }
                }
            }
        }

        public void MensajeEncola()
        {
            //guardamos los mensajes en cola si ocurre error
            string rutaCola = @".\private$\queja";
            if (!MessageQueue.Exists(rutaCola))
            {
                MessageQueue.Create(rutaCola);
            }
            MessageQueue cola = new MessageQueue(rutaCola);
            Message mensaje = new Message();
            mensaje.Label = "Queja registrada con fecha " + DateTime.Now.ToShortDateString();
            mensaje.Body = new  Queja()
            {
                N_IdResidente = 2,
                B_Estado = false,
                C_Detalle = "detalle",
                C_Motivo = "motivo",
                C_Tipo = "Grave",
                D_FecQueja = "2014-06-12",
                D_FecRegistro = new DateTime(10,10,10,10,10,10)
            };
            cola.Send(mensaje);

            //recuperamos el mensaje
            MessageQueue cola2 = new MessageQueue(rutaCola);

            int cantidadmensajes = 0;

            if (MessageQueue.Exists(rutaCola))
            {
                cantidadmensajes = cola2.GetAllMessages().Count();
                //recorrer y grabar
                foreach (Message mensajeTodo in cola2.GetAllMessages())
                {
                    mensajeTodo.Formatter = new XmlMessageFormatter(new Type[] { typeof(Queja) });
                    Queja ObjQueja = (Queja)mensajeTodo.Body;
                    //buscamos el que se envio
                    if (ObjQueja.N_IdResidente == 2 & ObjQueja.D_FecQueja == "2014-06-12")
                    {
                        Assert.AreEqual(false, ObjQueja.B_Estado);
                        Assert.AreEqual("detalle", ObjQueja.C_Detalle);
                        Assert.AreEqual("motivo", ObjQueja.C_Motivo);
                        Assert.AreEqual("Grave", ObjQueja.C_Tipo);
                        Assert.AreEqual(new DateTime(10, 10, 10, 10, 10, 10), ObjQueja.D_FecRegistro);
                        cola2.Receive();
                        break;
                    }

                }

                //se elimina los mensajes

                MessageQueue.Delete(rutaCola);
            }
            Assert.AreNotEqual(0, cantidadmensajes);
        }

        public ICollection<Favorito> ListarFavoritos(int idTorneo, int idParticipante)
        {
            string rutaCola = @".\private$\DSWarrior2";

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

            var cola = new MessageQueue(rutaCola);
            cola.Formatter = new XmlMessageFormatter(new Type[] { typeof(Favorito) });

            var lista = new List<Favorito>();
            var messages = cola.GetAllMessages();
            var totalMessages = messages.Count();

            for (int i = 0; i < totalMessages; i++)
            {
                var mensaje = messages[i];
                var favorito = (Favorito)mensaje.Body;

                if (favorito.IDTorneo == idTorneo && favorito.IDParticipante == idParticipante) {
                    lista.Add(favorito);
                }
            }

            return lista;
            //return favoritoDA.ListarFavoritos(idTorneo, idParticipante);
        }

        public object receiveByID(string MessageID, string InputQueue)
        {
            // Open existing queue
            using (MessageQueue queue = new MessageQueue(InputQueue))
            {
                //Peek to find message with the MessageID in the label
                while (true)
                {
                    Message[] peekedmessage = queue.GetAllMessages();
                    foreach (Message m in peekedmessage)
                    {
                        if (m.Label.StartsWith(MessageID))
                        {
                            using (Message message = queue.ReceiveById(m.Id))
                            {
                                RequestGuid = MessageID;
                                // Gets object type from the message label
                                Type objType = Type.GetType(message.Label.Split('|')[1], true, true);

                                // Derializes object from the stream
                                DataContractSerializer serializer = new DataContractSerializer(objType);
                                return serializer.ReadObject(message.BodyStream);
                            }
                        }
                    }
                    System.Threading.Thread.Sleep(10);
                }
            }
        }

        public string enviarPromociones()
        {
            string resultado = string.Empty;
            try
            {

                string rutaCola = @".\private$\CitasClinica";
                if (!MessageQueue.Exists(rutaCola))
                    MessageQueue.Create(rutaCola);
                MessageQueue cola = new MessageQueue(rutaCola);
                cola.Formatter = new XmlMessageFormatter(new Type[] { typeof(Cita) });

                foreach (var msj in cola.GetAllMessages())
                {
                    Message mensaje = cola.Receive();
                    Cita citaBE = (Cita)mensaje.Body;
                    enviarCorreo(citaBE);
                }
                resultado = "Se envio las promociones OK";
            }
            catch (Exception)
            {
                resultado = "No se enviaron las promociones";
            }
            return resultado;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                config = new Utils.ReadConfigure().GetConfig();
                lblConfig.Text = lblConfig.Text + " OK";

                GetCertificado();
                lblCertificado.Text = lblCertificado.Text + " OK";


                MessageQueue mq = new MessageQueue(@".\Private$\nfce_contingencia", false);

               


                lblFila.Text += mq.GetAllMessages().Count();
                    
                
                enviaSeFaz = new EnviaSeFaz.ManagerSeFaz(config, cert);
                
                enviaSeFaz.verificaStatusSefaz();
                lblStatusSefaz.Text = lblStatusSefaz.Text + " OK";

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }

        }

        void ISubscriptionStorage.Init()
        {
            var path = MsmqUtilities.GetFullPath(Queue);

            q = new MessageQueue(path);

            bool transactional;
            try
            {
                transactional = q.Transactional;
            }
            catch (Exception ex)
            {
                throw new ArgumentException(string.Format("There is a problem with the subscription storage queue {0}. See enclosed exception for details.", Queue), ex);
            }

            if (!transactional && TransactionsEnabled)
                throw new ArgumentException("Queue must be transactional (" + Queue + ").");

            var messageReadPropertyFilter = new MessagePropertyFilter { Id = true, Body = true, Label = true };

            q.Formatter = new XmlMessageFormatter(new[] { typeof(string) });

            q.MessageReadPropertyFilter = messageReadPropertyFilter;

            foreach (var m in q.GetAllMessages())
            {
                var subscriber = Address.Parse(m.Label);
                var messageTypeString = m.Body as string;
                var messageType = new MessageType(messageTypeString); //this will parse both 2.6 and 3.0 type strings

                entries.Add(new Entry { MessageType = messageType, Subscriber = subscriber });
                AddToLookup(subscriber, messageType, m.Id);
            }
        }

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

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

        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 Ubicacion listaUbicacion(string idenvio)
        {
            string rutaCola = @".\private$\proyecto";
            if (!MessageQueue.Exists(rutaCola))
                MessageQueue.Create(rutaCola);
            MessageQueue cola = new MessageQueue(rutaCola);

            ///regularizar peidos
            int x = cola.GetAllMessages().Count();

            for (int i = 1; i <= x; i++)
            {

                cola.Formatter = new XmlMessageFormatter(new Type[] { typeof(Ubicacion) });

                Message mensaje = cola.Receive();
                Ubicacion nota = (Ubicacion)mensaje.Body;

                string pedido = ubicacion(nota);

            }

              //Ubicacion ubi = tdao.ObtenerUbicacion(idenvio);

              //  //if(ubi==null){

            //    throw new FaultException("No tiene pedidos en ruta", FaultCode.CreateSenderFaultCode("Fallo", "No tiene pedidos en ruta"),"G");

            //}

            return tdao.ObtenerUbicacion(idenvio);
        }

		public string GetElementFromDestination(string pQueuePach)
		{
			System.Messaging.Message sourceMessage;
			string str="";
			try
			{
				destinationQueue = new System.Messaging.MessageQueue(pQueuePach);
				((XmlMessageFormatter)destinationQueue.Formatter).TargetTypeNames = new string[]{"System.String"};
				if(destinationQueue.GetAllMessages ().Length >0)
				{
					sourceMessage = destinationQueue.Receive(System.Messaging.MessageQueueTransactionType.Automatic);
				
					//	destinationQueue.Formatter = new XmlMessageFormatter(new Type[]	{typeof(String)});
					((XmlMessageFormatter)destinationQueue.Formatter).TargetTypeNames = new string[]{"Empleado"};


					str = (string)sourceMessage.Body;
				}
			
				return str;
			}
			catch(MessageQueueException e)
			{
				throw e;
			}
					
		}

        public async Task ShouldRemoveSubscriptionsInNonTransactionalMode()
        {
            var address = MsmqAddress.Parse("MsmqSubscriptionStorageQueueTests.PersistNonTransactional");
            var queuePath = address.PathWithoutPrefix;

            if (MessageQueue.Exists(queuePath))
            {
                MessageQueue.Delete(queuePath);
            }

            MessageQueue.Create(queuePath, false);

            using (var queue = new MessageQueue(queuePath))
            {
                queue.Send(new Message
                {
                    Label = "subscriber",
                    Body = typeof(MyMessage).AssemblyQualifiedName
                }, MessageQueueTransactionType.None);
            }

            var storage = new MsmqSubscriptionStorage(new MsmqSubscriptionStorageQueue(address, false));

            storage.Init();

            await storage.Unsubscribe(new Subscriber("subscriber", "subscriber"), new MessageType(typeof(MyMessage)), new ContextBag());

            using (var queue = new MessageQueue(queuePath))
            {
                CollectionAssert.IsEmpty(queue.GetAllMessages());
            }
        }

        static void Main(string[] args)
        {
            cmdLine = args;

            var timeOfMigration = DateTime.UtcNow;

            var storage = GetSetting("-storageQueue");

            var inputStorageQueue = Address.Parse(storage);

            var destination = GetSetting("-destination");
            newTimeoutManagerAddress = Address.Parse(destination);

            var minAge = GetSetting("-migrateOlderThan");

            var minAgeOfTimeouts = TimeSpan.MinValue;
            if (!string.IsNullOrEmpty(minAge))
                minAgeOfTimeouts = TimeSpan.Parse(minAge);

            bus = Configure.With()
               .DefaultBuilder()
               .XmlSerializer()
               .MsmqTransport()
               .UnicastBus()
               .SendOnly();

            var path = MsmqUtilities.GetFullPath(inputStorageQueue);

            storageQueue = new MessageQueue(path) { MessageReadPropertyFilter = { LookupId = true } };

            if (!storageQueue.Transactional)
                throw new Exception(inputStorageQueue + " must be transactional.");

            storageQueue.Formatter = new XmlMessageFormatter(new[] { typeof(TimeoutData) });

            Console.WriteLine(string.Format("Parsing {0} to find timeouts to migrate", inputStorageQueue));

            storageQueue.GetAllMessages().ToList().ForEach(
                m =>
                {
                    var timeoutData = m.Body as TimeoutData;
                    if (timeoutData == null) //get rid of message
                        throw new InvalidOperationException("Failed to parse timeout data with id " + m.Id);

                    if (minAgeOfTimeouts != TimeSpan.MinValue && timeoutData.Time < (timeOfMigration + minAgeOfTimeouts))
                    {
                        Console.WriteLine(string.Format("Timeout {0} has a expiry ({1}) less than the configured min age of {2} and will be ignored", m.Id, timeoutData.Time, minAgeOfTimeouts));
                        return;
                    }
                    timeoutsToBeMigrated.Add(new Tuple<TimeoutData, string>(timeoutData, m.Id));
                });

            Console.WriteLine(string.Format("{0} parsed, {1} timeouts found that will be migrated", inputStorageQueue, timeoutsToBeMigrated.Count()));

            timeoutsToBeMigrated.ForEach(t => MigrateMessage(t.Item1, t.Item2));

            Console.WriteLine(string.Format("Migration completed successfully"));
        }