private void Route(object source, ReceiveCompletedEventArgs result) { try { MessageQueue queue = (MessageQueue) source; Message message = queue.EndReceive(result.AsyncResult); TraceMessage(message); // read topic from the message Extension byte[] bytes = message.Extension; string topic = Encoding.Unicode.GetString(bytes); // Look up the target queue for the topic MessageQueue topicQueue; if (routingTable.TryGetValue(topic, out topicQueue)) { // Send to the target queue topicQueue.Send(message); } } catch (MessageQueueException mqe) { Console.WriteLine("{0} {1}", mqe.Message, mqe.MessageQueueErrorCode); } Receive(); }
static void q_ReceiveCompleted(object sender, ReceiveCompletedEventArgs e) { lock (_lock) { SendMail((Email)e.Message.Body); } _q.BeginReceive(); }
/// <summary> /// ReceiveCompleted /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public void ReceiveCompleted(object sender, ReceiveCompletedEventArgs e) { try { lock (_obj) { var messageQueue = (MessageQueue)sender; var message = messageQueue.EndReceive(e.AsyncResult); var messageObj = (LogMessage)message.Body; _dbContext.LogMessages.Add(messageObj); _dbContext.SaveChanges(); } } catch (Exception ex) { _dbContext.LogMessages.Add(new LogMessage() { CreatTime = DateTime.Now, Status = Status.Error, JobName = "MqReceiveError", ErrorMsg = ex.Message + ex.StackTrace, RequestTime = DateTime.Now }); } }
/// <summary> /// Event fires when a message arrives on the queue. Pulls the message and hands /// the information off to the AssignmentManager.ServerAction class to process /// </summary> public void OnReceiveCompleted(Object source, System.Messaging.ReceiveCompletedEventArgs e) { ServerAction sa = new ServerAction(); // grab the queue information MessageQueue mq = (MessageQueue)source; // grab the message System.Messaging.Message m = mq.EndReceive(e.AsyncResult); m.Formatter = new System.Messaging.XmlMessageFormatter(new String[] { "System.String" }); // process the message string msgBody = (string)m.Body; try { bool result = sa.ProcessMessage(msgBody, m.Label); } catch (System.Exception ex) { System.Diagnostics.EventLog.WriteEntry(this.ServiceName.ToString(), ex.ToString()); } finally { // continue listening on the queue mq.BeginReceive(); } }
private static void QueueMessageReceived(object sender, ReceiveCompletedEventArgs e) { try { MessageQueue msQueue = (MessageQueue)sender; //once a message is received, stop receiving Message msMessage = msQueue.EndReceive(e.AsyncResult); //do something with the message Trace.WriteLine("Received message body in MSMQService: " + msMessage.Body + " at " + DateTime.Now); Functions.ProcessQueueMessage(msMessage.Body.ToString()); //set the signal count += 1; if (count == 10) { signal.Set(); } //Restart the receive operation // Console.ReadLine(); //begin receiving again msQueue.BeginReceive(); } catch (Exception exc) { Trace.WriteLine(exc.Message); } }
private void ServerQueueOnReceiveCompleted(object sender, ReceiveCompletedEventArgs receiveCompletedEventArgs) { var queue = (MessageQueue) sender; using (Message clientRequest = queue.EndReceive(receiveCompletedEventArgs.AsyncResult)) { var request = clientRequest.Body as BasicMessage; if (request != null) { Console.WriteLine("Message Received from client:"); Console.WriteLine(" - " + request.Content); Console.WriteLine("Sending response in one moment..."); Thread.Sleep(1000); // Simulate some long process... using (MessageQueue responseQueue = clientRequest.ResponseQueue) // Note we don't need to know the address. { var response = new BasicMessage { Content = "Server response on " + DateTime.Now.ToShortTimeString() }; responseQueue.Send(response); } } } queue.BeginReceive(); }
protected virtual void MessageReceived(object sender, ReceiveCompletedEventArgs e) { lock(messageLock) { OnResponseReceived(new ResponseReceivedEventArgs((TwitterResponse)e.Message.Body)); } }
/// <summary> /// Finishes the asynchronous receive. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="System.Messaging.ReceiveCompletedEventArgs"/> instance containing the event data.</param> private void FinishReceive(object sender, ReceiveCompletedEventArgs e) { if (_messageQueue == null) { return; } try { _messageQueue.EndReceive(e.AsyncResult); // receive the current message var message = e.Message; var messageBody = message.Body as string; if (messageBody == null) { Log.Warn("msmq message body was invalid"); return; } // convert to an XML wrapper var messageInXml = XElement.Parse(messageBody); DecodeAndRouteEvent(messageInXml); } catch(MessageQueueException) { } catch(NullReferenceException) { } finally { // begin receiving the next message _messageQueue.BeginReceive(); } }
private void Consume(object source, ReceiveCompletedEventArgs result) { var message = channel.EndReceive(result.AsyncResult); message.TraceMessage(); if (isRunning) channel.BeginReceive(); }
static void ReceiveCompleted(object sender, ReceiveCompletedEventArgs e) { Log<Program>.Debug("Receiving message..."); var message = messageQueue.EndReceive(e.AsyncResult); Log<Program>.Info(message.Body.ToString()); messageQueue.BeginReceive(); }
/// <summary> /// Evenement declenché à la reception d'un message. /// </summary> /// <param name="source">Queue</param> /// <param name="asyncResult">Message</param> private void MyPeekCompleted(Object source, ReceiveCompletedEventArgs asyncResult) { // Récupère la queue. MessageQueue mq = (MessageQueue)source; System.Diagnostics.Debug.WriteLine("(Info) Reception d'une demande de reservation"); try { // Récupération du message. ProjetNet.Modele.ModeleReservation.ReservationHotelVol reservation = (ProjetNet.Modele.ModeleReservation.ReservationHotelVol) mq.EndPeek(asyncResult.AsyncResult).Body; WebServiceReservationSoap serviceReservationSOAP = new WebServiceReservationSoapClient(); ReserverRequestBody requestBody = new ReserverRequestBody(new WebServiceReservation.ReservationHotelVol() { Client = new WebServiceReservation.Client() { FirstName = reservation.Client.FirstName, LastName = reservation.Client.LastName, Mail = reservation.Client.Mail, Phone = reservation.Client.Phone, Address = reservation.Client.Address, City = reservation.Client.City, PostalCode = reservation.Client.PostalCode, Country = reservation.Client.Country }, Hotel = new WebServiceReservation.Hotel() { Name = reservation.Hotel.Name, Stars = reservation.Hotel.Stars, Price = reservation.Hotel.Price, City = reservation.Hotel.City, Country = reservation.Hotel.Country }, Vol = new WebServiceReservation.Vol() { Name = reservation.Vol.Name, From = reservation.Vol.From, To = reservation.Vol.To, Price = reservation.Vol.Price, Category = reservation.Vol.Category }, DateEnd = reservation.DateEnd, DateStart = reservation.DateStart }); ReserverRequest reserverRequest = new ReserverRequest(requestBody); // appel du WS serviceReservationSOAP.Reserver(reserverRequest); System.Diagnostics.Debug.Write("(Info) Reservation reussie."); } catch(Exception e) { System.Diagnostics.Debug.WriteLine("(Erreur) Reservation echouée : "); System.Diagnostics.Debug.WriteLine(e.Message); } finally { // Relance l'attente d'un message. mq.BeginReceive(); } }
static void ReceiveQueueMessage(object sender, ReceiveCompletedEventArgs e) { Log<Program>.Debug("Receiving queue message..."); var message = messageQueue.EndReceive(e.AsyncResult); var queueMessage = message.Body as QueueMessage; queueMessage.DoSomeWork(); messageQueue.BeginReceive(); }
private void HandleMessage (object source, ReceiveCompletedEventArgs args) { try { MessageQueue q = (MessageQueue) source; m = q.EndReceive (args.AsyncResult); state = (string) args.AsyncResult.AsyncState; } catch (Exception e) { failureMessage = e.Message; } }
private void OnReceive(object sender, ReceiveCompletedEventArgs e) { Message message = _messageQueue.EndReceive(e.AsyncResult); foreach (var subscriber in _subscribers) { subscriber.Invoke(message.Body); } ReceiveAsyncLoop(); }
private void OnReceived(object sender, ReceiveCompletedEventArgs e) { if (_shuttingDown) return; var msg = e.Message; _receiver.ReceivedLogEntry((LogEntryDTO) msg.Body); _queue.BeginReceive(); }
private void OnMessage(Object source, ReceiveCompletedEventArgs asyncResult) { var mq = (MessageQueue)source; Message message = mq.EndReceive(asyncResult.AsyncResult); if (IsConditionFulfilled()) outQueue1.Send(message); else outQueue2.Send(message); mq.BeginReceive(); }
void q_ReceiveCompleted(object sender, ReceiveCompletedEventArgs e) { //处理文件 var mq = (MessageQueue)sender; Message m = mq.EndReceive(e.AsyncResult); string fileId = m.Label; logger.Debug(fileId); //再次接收 mq.BeginReceive(MessageQueue.InfiniteTimeout); }
private static void Queue_ReceiveCompleted(object sender, ReceiveCompletedEventArgs e) { MessageQueue mq = (MessageQueue)sender; var message = mq.EndReceive(e.AsyncResult); System.Messaging.XmlMessageFormatter stringFormatter; stringFormatter = new System.Messaging.XmlMessageFormatter( new string[] { "System.String" }); message.Formatter = stringFormatter; Console.WriteLine(" e.Message:" + message.Body); mq.BeginReceive(); }
void requestQueue_ReceiveCompleted(object sender, ReceiveCompletedEventArgs e) { MessageQueue requestQueue = (MessageQueue)sender; Message requestMessage = requestQueue.EndReceive(e.AsyncResult); try { Console.WriteLine("Received request"); Console.WriteLine("\tTime: {0}", DateTime.Now.ToString("HH:mm:ss.ffffff")); Console.WriteLine("\tMessage ID: {0}", requestMessage.Id); Console.WriteLine("\tCorrel: {0}", requestMessage.CorrelationId); Console.WriteLine("\tReply To : {0}", "<n/a>"); Console.WriteLine("\tContents: {0}", requestMessage.Body.ToString()); string contents = requestMessage.Body.ToString(); MessageQueue replyQueue = requestMessage.ResponseQueue; Message replyMessage = new Message(); replyMessage.Body = contents; replyMessage.CorrelationId = requestMessage.Id; replyQueue.Send(replyMessage); Console.WriteLine("Sent 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()); } catch (Exception) { Console.WriteLine("Invalid message detected!"); Console.WriteLine("\tType: {0}", requestMessage.BodyType); Console.WriteLine("\tTime: {0}", DateTime.Now.ToString("HH:mm:ss.ffffff")); Console.WriteLine("\tMessage ID: {0}", requestMessage.Id); Console.WriteLine("\tCorrel: {0}", "<n/a>"); Console.WriteLine("\tReply To : {0}", "<n/a>"); requestMessage.CorrelationId = requestMessage.Id; controlQueue.Send(requestMessage); Console.WriteLine("Send to invalid message queue!"); Console.WriteLine("\tType: {0}", requestMessage.BodyType); Console.WriteLine("\tTime: {0}", DateTime.Now.ToString("HH:mm:ss.ffffff")); Console.WriteLine("\tMessage ID: {0}", requestMessage.Id); Console.WriteLine("\tCorrel: {0}", requestMessage.CorrelationId); Console.WriteLine("\tReply To : {0}", requestMessage.ResponseQueue.Path); } requestQueue.BeginReceive(); }
private void OnReceiveCompleted(Object source, ReceiveCompletedEventArgs asyncResult) { var mq = (MessageQueue)source; Message inputMessage = mq.EndReceive(asyncResult.AsyncResult); inputMessage.Formatter = new XmlMessageFormatter(new String[] { "System.String,mscorlib" }); Message outputMessage = ProcessMessage(inputMessage); outputQueue.Send(outputMessage); mq.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(); }
private void Consume(object source, ReceiveCompletedEventArgs result) { // The Consume method is called on completion of a message being received // We need to obtain the message from the result by calling EndRecieve Message message = channel.EndReceive(result.AsyncResult); message.TraceReceivedMessage(); // We also want to begin receiving again, unless we have stopped running if (isRunning) { channel.BeginReceive(); } }
void MessageQueueReceiveCompleted(object sender, ReceiveCompletedEventArgs e) { var messageQueue = (MessageQueue) sender; try { Message message = messageQueue.EndReceive(e.AsyncResult); _messageHandler.Handle((IMessage) message.Body); } finally { messageQueue.BeginReceive(); } }
void Recover(object sender, ReceiveCompletedEventArgs e) { var queue = sender as MessageQueue; try { Message msg = queue.EndReceive(e.AsyncResult); SecsMessage secsMsg = msg.Body as SecsMessage; if (secsMsg != null) _subscription.Handle(secsMsg); queue.BeginReceive(TimeSpan.FromSeconds(QUEUE_RECEIVE_TIMEOUT)); } catch (MessageQueueException) { _serverDisposable.RecoverComplete(); queue.Close(); MessageQueue.Delete(_queuePath); } }
static void msgQ_RecieveCompleted(object sender, ReceiveCompletedEventArgs e) { lock (lockObject) //mutex { MailMessageWrapper mailMessageWrapper = (MailMessageWrapper)e.Message.Body; MailMessage msg = mailMessageWrapper.BuildMail(); smtpClient.Send(msg); Debug.WriteLine("HASAN JEBENI SAKIC PIZDA MU MATERINA"); Console.WriteLine("Message recieved: " + mailMessageWrapper.Body); } msgQ.BeginReceive(); }
/// <summary> /// Callback function that is called when a message is picked up /// </summary> /// <param name="sender">Object that calls the callback</param> /// <param name="e">Event arguments</param> private void ReceiveCompleted(object sender, ReceiveCompletedEventArgs e) { try { Message m = this.MQ.EndReceive(e.AsyncResult); this.RaiseMessageReceived(m.Body); } catch (Exception ex) { } finally { this.MQ.BeginReceive(); } }
public static void mq_ReceiveCompletedReply(object sender, ReceiveCompletedEventArgs e) { MessageQueue cmq = (MessageQueue)sender; try { System.Messaging.Message msg = cmq.EndReceive(e.AsyncResult); var messageLabel = msg.Label; var procID = UInt32.Parse(messageLabel); GetProcess(procID); } catch { } cmq.Refresh(); cmq.BeginReceive(); }
// // Message receiving handler // private void qMe_ReceiveCompleted(object sender, System.Messaging.ReceiveCompletedEventArgs e) { Util.line lineToDraw = new Util.line(); MessageQueue mq = (MessageQueue)sender; System.Messaging.Message m = mq.EndReceive(e.AsyncResult); if (m.Body.ToString().Length == 1) { // Draw a char DrawChar(m.Body.ToString()); } else { // Draw a line HP.StringToLine(m.Body.ToString(), ref lineToDraw); AddLine(lineToDraw, picture1Graphics); } mq.BeginReceive(); }
static void MessageQueueReceiveCompleted(object sender, ReceiveCompletedEventArgs e) { logQueue.EndReceive(e.AsyncResult); var message = (string)e.Message.Body; Console.WriteLine(message); //deserialize to dynamic object, so we can dump whatever properties we want to the database, //without needing to change any of this code var logEntry = JsonConvert.DeserializeObject<ExpandoObject>(message); //Console.WriteLine(logEntry); //now that we have this object, we can dump it to mongoDB, right? var dict = logEntry.ToDictionary(en => en.Key, en => en.Value); mongoDBWriter.WriteEntry(dict); DoReceive(); }
private void Consume(object source, ReceiveCompletedEventArgs result) { try { var queue = (MessageQueue) source; var message = queue.EndReceive(result.AsyncResult); if (message != null) { message.TraceMessage(); } } catch (MessageQueueException mqe) { Console.WriteLine("{0} {1}", mqe.Message, mqe.MessageQueueErrorCode); } Receive(); }
private void qOrders_ReceiveCompleted(object sender, System.Messaging.ReceiveCompletedEventArgs e) { // This event fires when a message is received. try { // Get the message Message m; m = qOrders.EndReceive(e.AsyncResult); // Cast the message body to an object instance Server.MSMQOrders o; o = (Server.MSMQOrders)m.Body; // if we did the following line of code: // o.Process() // our listening thread would be blocked until // it finished. Instead will use the built-in // CLR Thread Pool. // Note that our MSMQOrders.Process method has to match // expected signature defined by the QueueUserWorkItem method. // See the documenation for more information. ThreadPool.QueueUserWorkItem(new WaitCallback(o.Process)); // Now continue listening for messages this.qOrders.BeginReceive(); } catch (MessageQueueException exp) { this.EventLog.WriteEntry(exp.Message); } catch (Exception exp) { this.EventLog.WriteEntry(exp.Message); } }
public static void ProcessOrder(Object source,ReceiveCompletedEventArgs asyncResult) { try { // Connect to the queue. MessageQueue Queue = (MessageQueue)source; // End the asynchronous receive operation. System.Messaging.Message msg = Queue.EndReceive(asyncResult.AsyncResult); msg.Formatter = new System.Messaging.XmlMessageFormatter(new Type[] { typeof(PurchaseOrder) }); PurchaseOrder po = (PurchaseOrder) msg.Body; Random statusIndexer = new Random(); po.Status = (OrderStates)statusIndexer.Next(3); Console.WriteLine("Processing {0} ", po); Queue.BeginReceive(); } catch (System.Exception ex) { Console.WriteLine(ex.Message); } }
private void Route(object source, ReceiveCompletedEventArgs result) { try { var queue = (MessageQueue) source; var message = queue.EndReceive(result.AsyncResult); TraceMessage(message); var topic = Encoding.ASCII.GetString(Convert.FromBase64String(Encoding.ASCII.GetString(message.Extension))); Console.WriteLine("Topic is {0}.", topic); var topicQueue = routingTable[topic]; topicQueue.Send(message); } catch (MessageQueueException mqe) { Console.WriteLine("{0} {1}", mqe.Message, mqe.MessageQueueErrorCode); } Receive(); }
private void drawingMQ_ReceiveCompleted(object sender, System.Messaging.ReceiveCompletedEventArgs e) { System.Messaging.Message m; MSMQGraphics.Drawing d; try { if (e.Message != null) { m = e.Message; m.Formatter = new XmlMessageFormatter(new Type[] { typeof(MSMQGraphics.Drawing), typeof(MSMQGraphics.Line) }); d = (MSMQGraphics.Drawing)m.Body; thisDrawing = d; pictureBox1.Invalidate(); } } catch { } drawingMQ.BeginReceive(new TimeSpan(0, 0, 3)); }