private void Queue_PeekCompleted(object sender, PeekCompletedEventArgs e)
{
MessageQueue queue = (MessageQueue)sender;
queue.EndPeek(e.AsyncResult);
using (MessageQueueTransaction tx = new MessageQueueTransaction())
{
tx.Begin();
var message = queue.Receive(tx);
message.Formatter = new XmlMessageFormatter(_incomingHandlers.SelectMany(h => h.Value).Distinct().ToArray());
var messageType = message.Body.GetType();
var handlers = GetHandlersInstanceFor(messageType);
foreach (var handler in handlers)
{
HandleMessage(message.Body, handler);
}
tx.Commit();
}
queue.BeginPeek();
}
//**************************************************
// Provides an event handler for the PeekCompleted
// event.
//**************************************************
private static void MyPeekCompleted(Object source,
PeekCompletedEventArgs asyncResult)
{
try
{
// Connect to the queue.
MessageQueue mq = (MessageQueue)source;
// End the asynchronous peek operation.
Message m = mq.EndPeek(asyncResult.AsyncResult);
// Display message information on the screen.
Console.WriteLine("Message: " + (string)m.Body);
// Restart the asynchronous peek operation, with the
// same time-out.
mq.BeginPeek(new TimeSpan(0, 1, 0));
}
catch (MessageQueueException e)
{
if (e.MessageQueueErrorCode ==
MessageQueueErrorCode.IOTimeout)
{
Console.WriteLine(e.ToString());
}
// Handle other sources of MessageQueueException.
}
// Handle other exceptions.
return;
}
/// <summary>
/// Receive request from the worker on either :Peek event or Receive event
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private Response HandleIncomingRequest(RequestReceive request)
{
ResultModel resultModel = Converter.FromByteArray(request.Body) as ResultModel;
switch (request.Metadata)
{
case "PeekOK":
PeekCompletedEventArgs PeekArgs = new PeekCompletedEventArgs();
PeekArgs.Message = resultModel.message;
peekCompleted?.Invoke(this, PeekArgs);
break;
case "RecieveOK":
ReceiveCompletedEventArgs receiveCompletedEventArgs = new ReceiveCompletedEventArgs();
receiveCompletedEventArgs.Message= resultModel.message;
receiveCompleted?.Invoke(this, receiveCompletedEventArgs);
break;
default:
break;
}
return new Response(request)
{
Metadata = "OK",
Body = Converter.ToByteArray("OK"),
CacheHit = false,
ClientID = $"MSMQWorker{Path}",
Timestamp=DateTime.UtcNow,
Executed=true,
Error=""
};
}
/// <summary>
/// Peek Event Handler
/// </summary>
private async Task MyPeekCompleted(object source,
PeekCompletedEventArgs asyncResult, string ChannelToReturnTo, string channelPeeked)
{
ResultModel resultModel = new ResultModel();
try
{
// Connect to the queue.
System.Messaging.MessageQueue mq = (System.Messaging.MessageQueue)source;
// End the asynchronous peek operation.
System.Messaging.Message myMessage = mq.EndPeek(asyncResult.AsyncResult);
resultModel.message = MessageConvert.ConvertFromSystemMessage(myMessage);
resultModel.Result = (int)ResultsEnum.Done;
// Restart the asynchronous peek operation.
Response response = await initiator.SendRequestAsync(new KubeMQ.SDK.csharp.CommandQuery.LowLevel.Request()
{
Metadata = "PeekOK",
Body = Converter.ToByteArray(resultModel),
CacheKey = "",
CacheTTL = 0,
Channel = ChannelToReturnTo,
ClientID = clientID,
RequestType = RequestType.Query
});
}
catch (Exception ex)
{
_logger.LogCritical(string.Format("Failed to peek path {0} on ex {1}", channelPeeked, ex.Message));
}
}
void mq_PeekCompleted(object sender, PeekCompletedEventArgs e)
{
var queue = (MessageQueue)sender;
var type = this.SupportDataTypes.FirstOrDefault(t => t.FullName.To16bitMD5().Equals(e.Message.Label));
if (type != null)
{
queue.Formatter = new JsonMessageFormater(type);
//queue.Formatter = new ProtoBufFormatter(typeof(T));
using (var transaction = new TransactionScope()) {
var msg = queue.EndPeek(e.AsyncResult);
if (this.OnDataReceived != null)
{
this.OnDataReceived(null, new DataReceivedArgs(msg.Body));
}
//在远程队列上 (WIN7)，用 Automatic 会抛出异常。
//try {
// queue.ReceiveById(e.Message.Id, MessageQueueTransactionType.Single);
//} catch {
// queue.ReceiveById(e.Message.Id, MessageQueueTransactionType.Automatic);
//}
queue.Receive();
transaction.Complete();
}
}
queue.BeginPeek();
}
protected void PeekCompleted(object sender, PeekCompletedEventArgs e)
{
System.Messaging.Message msg = null;
MessageQueue mq = null;
try
{
mq = (MessageQueue)sender;
mq.Formatter = new BinaryMessageFormatter();
System.Messaging.Message m = mq.EndPeek(e.AsyncResult);
mq.ReceiveById(m.Id);
if (OnMessageArrivedHandle != null)
{
OnMessageArrivedHandle(m.Label, m.Body.ToString());
}
}
catch (Exception ex) { string err = ex.Message; }
finally
{
if (msg != null)
{
try { msg.Dispose(); }
catch { }
finally { msg = null; }
}
//接收下一次事件
if (mq != null)
{
mq.BeginPeek();
}
}
}
private void OnPeekCompleted(object sender, PeekCompletedEventArgs e)
{
if (OnMessage == null)
{
return;
}
var transaction = new MessageQueueTransaction();
transaction.Begin();
try
{
var queueMessage = inputQueue.Receive(transaction);
var headers = GetMessageHeaders(queueMessage);
var message = new ChannelMessage(queueMessage.BodyStream);
message.AddHeader(headers);
OnMessage(message);
transaction.Commit();
}
catch (Exception)
{
transaction.Abort();
throw;
}
finally
{
inputQueue.BeginPeek();
}
}
private void queue_NoTransaction(object sender, PeekCompletedEventArgs e)
{
var queue = (MessageQueue)sender;
try
{
// if the queue closes after the transaction begins,
// but before the call to Receive, then an exception
// will be thrown and the transaction will be aborted
// leaving the message to be processed next time
var msg = queue.Receive(MessageQueueTransactionType.Automatic);
Handle(msg);
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message);
}
finally
{
if (!this.IsClosing)
{
queue.BeginPeek();
}
}
}
private static void OnPeekCompleted(Object source, PeekCompletedEventArgs asyncResult)
{
// Connect to the queue.
MessageQueue mq = (MessageQueue)source;
// create transaction
using (var txn = new MessageQueueTransaction())
{
try
{
// retrieve message and process
txn.Begin();
// End the asynchronous peek operation.
var message = mq.Receive(txn);
// Display message information on the screen.
if (message != null)
{
Console.WriteLine("{0}: {1}", message.Label, (string)message.Body);
}
// message will be removed on txn.Commit.
txn.Commit();
}
catch (Exception ex)
{
// on error don't remove message from queue
Console.WriteLine(ex.ToString());
txn.Abort();
}
}
// Restart the asynchronous peek operation.
mq.BeginPeek();
}
private void SourceQueuePeekCompleted(object sender, PeekCompletedEventArgs e)
{
lock (_lockObject)
{
MessageQueueTransaction trans = new MessageQueueTransaction();
trans.Begin();
Message message = _queue.Receive(trans);
_traceSource.TraceInformation("Message Received: " + message.Label);
try
{
ProcessMessage(message);
}
catch
{
if (_errorQueue != null)
{
_errorQueue.Send(message, trans);
}
}
trans.Commit();
}
_queue.BeginPeek();
}
void OnPeekCompleted(object sender, PeekCompletedEventArgs peekCompletedEventArgs)
{
stopResetEvent.Reset();
CallPeekWithExceptionHandling(() => queue.EndPeek(peekCompletedEventArgs.AsyncResult));
throttlingSemaphore.Wait();
Task.Factory
.StartNew(Action, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default)
.ContinueWith(task =>
{
task.Exception.Handle(ex =>
{
Logger.Error("Error processing message.", ex);
return(true);
});
}, TaskContinuationOptions.OnlyOnFaulted);
//We using an AutoResetEvent here to make sure we do not call another BeginPeek before the Receive has been called
peekResetEvent.WaitOne();
CallPeekWithExceptionHandling(() => queue.BeginPeek());
stopResetEvent.Set();
}
/// <summary>
///
/// </summary>
/// <param name="source"></param>
/// <param name="asyncResult"></param>
protected virtual void MessagePeekCompleted(object source, PeekCompletedEventArgs asyncResult)
{
var messageQueue = (MessageQueue)source;
var message = messageQueue.EndPeek(asyncResult.AsyncResult);
if (!(message.Body is IServiceMessage))
{
return;
}
var messageContent = (IServiceMessage)message.Body;
if (messageContent.SourceServiceGuid != ServiceId)
{
return;
}
Task.Run(() => ProcessMessage(messageContent));
if (IsRuning)
{
messageQueue.BeginPeek();
}
}
private void QueuePeekCompleted(object sender, PeekCompletedEventArgs e)
{
var messageQueue = (MessageQueue)sender;
messageQueue.EndPeek(e.AsyncResult);
Message message = null;
try
{
message = messageQueue.Receive();
if (message == null)
{
throw new InvalidOperationException("Null message");
}
message.Formatter = (IMessageFormatter)MessageFormatter.Clone();
Trace.WriteLine(string.Format("Received message {0}", message.Id));
var command = (Int32)message.AppSpecific;
var handlers = _messageHandlers
.Where(x => x.Key == command)
.Select(x => x.Value)
.Where(x => x != null)
.ToArray();
var handlerCount = handlers.Count();
Trace.WriteLine(string.Format("Executing {0} handlers", handlerCount));
if (!handlers.Any())
{
handlers = new Action <object>[] { msg => Trace.TraceWarning("Message {0} has no registered handlers", message.Id) }
}
;
foreach (var handler in handlers)
{
if (command == MessageCommand)
{
handler(message.Body);
}
else
{
handler(message);
}
}
}
catch (Exception ex)
{
LogError(message, ex);
}
messageQueue.Refresh();
messageQueue.BeginPeek();
}
public static void QueuePeeker(object src, PeekCompletedEventArgs rcea)
{
MessageQueue q = (MessageQueue)src;
Message m = q.EndReceive(rcea.AsyncResult);
receiveMessageDepartment();
q.BeginPeek();
}
private void QueuePeekCompleted(object sender, PeekCompletedEventArgs e)
{
var message = _queue.EndPeek(e.AsyncResult);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\nA message was read from the Customers queue.");
Console.WriteLine(string.Format("The message was: {0}", message.Body));
_queue.Receive();
_queue.BeginPeek();
}
private void PeekCompleted(object source, PeekCompletedEventArgs eventArgs)
{
var abortQueue = false;
try
{
using (var peek = _localQueue.EndPeek(eventArgs.AsyncResult))
{
if (peek.AppSpecific != APP_SPECIFIC_STOP)
{
foreach (var conversation in LargeMessage.GetAvailableConversations(_localQueue))
{
OnProcessMessage(_mode, _localQueue, conversation);
}
}
else
{
_localQueue.ReceiveById(peek.Id, MessageQueueTransactionType.Single).Dispose();
DisposeLocalQueue();
}
}
}
catch (MessageQueueException me)
{
if (me.MessageQueueErrorCode != MessageQueueErrorCode.IOTimeout &&
me.MessageQueueErrorCode != MessageQueueErrorCode.TransactionEnlist)
{
abortQueue = true;
}
}
catch (SqlException)
{
abortQueue = true;
}
catch (TransactionAbortedException)
{
abortQueue = true;
}
catch
{
abortQueue = true;
}
if (abortQueue)
{
DisposeLocalQueue();
}
else if (_started)
{
Thread.Sleep(SLEEP_PEEK_NEXT_MESSAGE);
_localQueue.BeginPeek();
}
}
private void Queue_PeekCompleted(object sender, PeekCompletedEventArgs e)
{
// end peek operation
var queue = (MessageQueue)sender;
queue.EndPeek(e.AsyncResult);
// read message transactionally
MessageQueueTransaction transaction = null;
try
{
transaction = new MessageQueueTransaction();
transaction.Begin();
// if the queue closes after the transaction begins,
// but before the call to Receive, then an exception
// will be thrown and the transaction will be aborted
// leaving the message to be processed next time
Message message = queue.Receive(TimeSpan.Zero, transaction);
ProcessMessage(message, queue, transaction);
transaction.Commit();
}
catch (MessageQueueException ex)
{
transaction?.Abort();
// timeout is expected here, sometimes
if (ex.MessageQueueErrorCode != MessageQueueErrorCode.IOTimeout)
{
Log.Error(ex.GetType().ToString(), ex);
}
}
catch (Exception ex)
{
// something unexpected happened
transaction?.Abort();
Log.Error(ex.GetType().ToString(), ex);
}
finally
{
transaction?.Dispose();
// start new peek operation
if (_isClosing == false)
{
queue.BeginPeek();
}
}
}
private void Queue_PeekCompleted(object sender, PeekCompletedEventArgs e)
{
MessageQueue queue = (MessageQueue)sender;
queue.EndPeek(e.AsyncResult);
using (MessageQueueTransaction tx = new MessageQueueTransaction())
{
tx.Begin();
var message = queue.Receive(tx);
message.Formatter = new XmlMessageFormatter(_incomingHandlers.SelectMany(h => h.Value).Distinct().ToArray());
var messageType = message.Body.GetType();
var handlers = GetHandlersInstanceFor(messageType);
foreach (var handler in handlers)
{
// if handler is saga and message.Body contains SagaId, populate data
if (IsImplementationOf(typeof(Saga <>), handler))
{
var bodyType = message.Body.GetType();
var sagaIdProperty = bodyType.GetProperties().FirstOrDefault(pi => pi.Name == "SagaId");
if (sagaIdProperty != null)
{
var sagaId = (Guid)sagaIdProperty.GetValue(message.Body);
if (sagaId != Guid.Empty)
{
if (!_sagaData.ContainsKey(sagaId))
{
var sagaDataType = GetSagaDataTypeFor((Type)handler.RealObject.GetType());
var instance = Activator.CreateInstance(sagaDataType);
instance.AsDynamic().SagaId = sagaId;
_sagaData.Add(sagaId, (SagaData)instance);
}
handler.Data = _sagaData[sagaId];
}
}
}
handler.Handle(message.Body);
}
tx.Commit();
}
queue.BeginPeek();
}
private void MessageAvailable(object source, PeekCompletedEventArgs args)
{
var messageQueue = (MessageQueue)source;
try
{
ReadMessage(messageQueue);
}
finally
{
messageQueue.Close();
}
// Continue reading from the queue
messageQueue.BeginPeek();
}
private void OnPeekCompleted(object source, PeekCompletedEventArgs asyncResult)
{
// Connect to the queue.
MessageQueue mq = (MessageQueue)source;
// create transaction
using (var txn = new MessageQueueTransaction())
{
try
{
// retrieve message and process
txn.Begin();
// End the asynchronous peek operation.
var message = mq.Receive(txn);
// Display message information on the screen.
if (message != null)
{
// determine the topic
var topic = (TopicType)Enum.Parse(typeof(TopicType), message.Label);
Console.WriteLine("{0} message received", topic);
if (ProcessCommand(message, topic))
{
// message will be removed on txn.Commit.
txn.Commit();
}
else
{
// Problem sending message on so put back in the queue
txn.Abort();
}
}
}
catch (Exception ex)
{
// on error don't remove message from queue
Console.WriteLine(ex.ToString());
txn.Abort();
}
}
// Restart the asynchronous peek operation.
mq.BeginPeek();
}
private void MessageHasBeenReceived(object sender, PeekCompletedEventArgs e)
{
var filas = MessageQueue.GetPrivateQueuesByMachine(Environment.MachineName);
var filaTeste = filas[0];
// Get message
var msg = filaTeste.EndPeek(e.AsyncResult);
// Do message processing here
// Remove message from queue
filaTeste.ReceiveById(msg.Id);
// Listen for more messages
filaTeste.BeginPeek();
filaTeste.PeekCompleted += new PeekCompletedEventHandler(MessageHasBeenReceived);
}
private void QueueOnPeekCompleted(object sender, PeekCompletedEventArgs peekCompletedEventArgs)
{
var asyncQueue = (MessageQueue)sender;
using (var transaction = new MessageQueueTransaction())
{
transaction.Begin();
try
{
using (var message = asyncQueue.ReceiveById(peekCompletedEventArgs.Message.Id, TimeSpan.FromSeconds(30), transaction))
{
if (message != null)
{
ProcessOrderQueue((OrderQueueDataContract)message.Body);
}
}
}
catch (InvalidOperationException ex)
{
transaction.Abort();
}
catch (Exception ex)
{
transaction.Abort();
}
if (transaction.Status != MessageQueueTransactionStatus.Aborted)
{
transaction.Commit();
}
else
{
using (var message = asyncQueue.ReceiveById(peekCompletedEventArgs.Message.Id, TimeSpan.FromSeconds(30), transaction))
{
if (message != null)
{
MoveMessageToDeadLetter(message);
message.Dispose();
}
}
EventLog.WriteEntry("OrderQueueProcessingService", "Could not process message: " + peekCompletedEventArgs.Message.Id);
}
transaction.Dispose();
}
asyncQueue.EndPeek(peekCompletedEventArgs.AsyncResult);
asyncQueue.BeginPeek();
}
//**************************************************
// Provides an event handler for the PeekCompleted
// event.
//**************************************************
private static void MyPeekCompleted(Object source,
PeekCompletedEventArgs asyncResult)
{
// Connect to the queue.
MessageQueue mq = (MessageQueue)source;
// End the asynchronous peek operation.
Message m = mq.EndPeek(asyncResult.AsyncResult);
// Display message information on the screen.
Console.WriteLine("Message: " + (string)m.Body);
// Restart the asynchronous peek operation.
mq.BeginPeek();
return;
}
private static void QueuePeekCompleted(object sender, PeekCompletedEventArgs e)
{
var cmq = (MessageQueue)sender;
cmq.EndPeek(e.AsyncResult);
Message msg = null; //keep outside scope to move this to the error log
try
{
msg = cmq.Receive();
if (msg == null)
{
throw new InvalidOperationException("Null message should not be possible");
}
if (msg.AppSpecific == 0)
{
HandleMessage(msg);
}
else
{
HandleSubscribeAndUnsubscribeMessage(msg);
}
}
catch (Exception ex)
{
ConsoleError("Exception in Peek: " + ex.Message);
if (msg != null)
{
using (var scope = new TransactionScope())
{
using (var myQueue = new MessageQueue(cmq.MachineName + "\\" + cmq.QueueName + "_errors"))
{
myQueue.Send(msg, MessageQueueTransactionType.Automatic);
}
scope.Complete();
}
}
}
cmq.Refresh();
cmq.BeginPeek();
}
private void OnPeekCompleted(object sender, PeekCompletedEventArgs e)
{
_queue.EndPeek(e.AsyncResult);
MessageQueueTransaction trans = new MessageQueueTransaction();
Message msg = null;
try
{
trans.Begin();
msg = _queue.Receive(trans);
trans.Commit();
StartListening();
FireRecieveEvent(msg.Body);
}
catch
{
trans.Abort();
}
}
private static void Queue_PeekCompleted(object sender, PeekCompletedEventArgs e)
{
MessageQueue queue = (MessageQueue)sender;
using (MessageQueueTransaction tx = new MessageQueueTransaction())
{
tx.Begin();
var message = queue.Receive(tx);
message.Formatter = new XmlMessageFormatter(new Type[] { typeof(HaveBreakfastCommand) });
var recievedMessage = (HaveBreakfastCommand)message.Body;
processMessage(recievedMessage);
tx.Commit();
}
queue.BeginPeek();
}
/// <summary>
/// Called when [peek completed].
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="PeekCompletedEventArgs"/> instance containing the event data.</param>
private void OnPeekCompleted(object sender, PeekCompletedEventArgs args)
{
messageQueue.EndPeek(args.AsyncResult);
MessageQueueTransaction transaction = new MessageQueueTransaction();
Message message = null;
try
{
transaction.Begin();
message = messageQueue.Receive(transaction);
transaction.Commit();
StartListening();
FireReceiveEvent(message.Body);
}
catch
{
transaction.Abort();
}
}
private void QueueOnPeekCompleted(object sender, PeekCompletedEventArgs peekCompletedEventArgs)
{
var asyncQueue = (MessageQueue)sender;
logger.DebugFormat("Peeked message with id {0}", peekCompletedEventArgs.Message.Id);
_receiveProvider.GetMessageFromQueue(
peekCompletedEventArgs.Message.Id,
asyncQueue,
delegate(Message message)
{
IConsumer consumer = null;
try
{
consumer = _registeredConsumers.FirstOrDefault(c => c.MessageType == message.Body.GetType());
}
catch (InvalidOperationException ex)
{
logger.Error("Failed to ready message body", ex);
}
catch (Exception ex)
{
logger.Error("Failed to get consumer, might be related to message body", ex);
}
if (consumer != null)
{
try
{
consumer.ProcessMessage(message);
}
catch (Exception ex)
{
logger.Warn("Failed to process message", ex);
}
}
});
logger.Debug("Peeking for next message.");
//peek next.
asyncQueue.BeginPeek();
}
private void PeekCompletedHandler(object sender, PeekCompletedEventArgs e)
{
var queue = (MessageQueue)sender;
Message queueMessage = null;
try
{
queue.EndPeek(e.AsyncResult);
queueMessage = queue.Receive();
ProcessMessage(queueMessage);
}
catch (Exception)
{
if (queueMessage != null)
{
SendToErrorQueue(queueMessage);
}
}
queue.BeginPeek();
}
private void OnPeekCompleted(object sender, PeekCompletedEventArgs e)
{
try
{
Process(e.Message.Body);
inQueue.EndPeek(beginPeekAsyncResult);
// only receive once peek is processed successfully otherwise the message is lost.
inQueue.Receive();
beginPeekAsyncResult = inQueue.BeginPeek();
}
catch (Exception ex)
{
// Ideally you'd be placing these in a Dead Letter Queue (DLQ) or Poison Queue...
if (processFailed != null)
{
processFailed(ex);
}
}
}
