public void Send(object message)
{
var transaction = new MessageQueueTransaction();
try
{
transaction.Begin();
_messageQueue.Send(message, transaction);
transaction.Commit();
}
catch
{
transaction.Abort();
throw;
}
finally
{
transaction.Dispose();
}
}
public Message GetFromQueue()
{
Message msg = null;
using (MessageQueueTransaction mqt = new MessageQueueTransaction())
{
try
{
mqt.Begin();
msg = _queue.Receive(mqt);
mqt.Commit();
}
catch (Exception)
{
mqt.Abort();
}
}
return(msg);
}
static MessageQueueTransaction GetTransaction(ITransactionContext context)
{
var transaction = context[CurrentTransactionKey] as MessageQueueTransaction;
if (transaction != null)
{
return(transaction);
}
transaction = new MessageQueueTransaction();
context[CurrentTransactionKey] = transaction;
context.DoCommit += transaction.Commit;
context.DoRollback += transaction.Abort;
context.Cleanup += transaction.Dispose;
transaction.Begin();
return(transaction);
}
private void OnMessagePeeked(object sender, PeekCompletedEventArgs e)
{
var transaction = new MessageQueueTransaction();
try
{
transaction.Begin();
var message = _messageQueue.Receive(transaction);
MessageReceived(this, new MessageReceivedEventArgs(message));
}
catch
{
transaction.Abort();
throw;
}
finally
{
transaction.Dispose();
}
}
public TransactionAction HandleFailedMessage(Message message, MessageQueueTransaction transaction)
{
if (message.Id != lastMessageId)
{
retries = 0;
lastMessageId = message.Id;
}
retries++;
if (retries > MAX_RETRIES)
{
//Trace.WriteLine("Sending to dead-letter queue");
deadLetterQueue.Send(message, transaction);
return(TransactionAction.COMMIT);
}
else
{
//Trace.WriteLine("Returning message to queue for retry: " + retries);
return(TransactionAction.ROLLBACK);
}
}
public void ReceiveByIdWithTransaction()
{
String body = "Message 4";
Message sent1 = new Message(body, new BinaryMessageFormatter());
MessageQueue mq = MQUtil.GetQueue(MQUtil.CreateQueueName(), true);
Assert.IsTrue(mq.Transactional, "Message Queue should be transactional");
mq.Send(sent1, MessageQueueTransactionType.Single);
string id = sent1.Id;
using (MessageQueueTransaction tx = new MessageQueueTransaction()) {
tx.Begin();
Message received1 = mq.ReceiveById(id, tx);
tx.Commit();
Assert.AreEqual(body, received1.Body);
}
}
private void button2_Click(object sender, EventArgs e)
{
using (MessageQueue mq = GetMQ())
{
using (MessageQueueTransaction tr = new MessageQueueTransaction())
{
tr.Begin();
System.Messaging.Message msg = mq.Receive(TimeSpan.FromSeconds(10), tr);
if (msg == null)
{
MessageBox.Show("Nada");
return;
}
Pepe p = (Pepe)msg.Body;
MessageBox.Show(p.ToString());
tr.Commit();
}
}
}
public void ReceiveWithTransactionAndTimeout()
{
String body = "Message 11";
Message sent1 = new Message(body, new BinaryMessageFormatter());
MessageQueue mq = MQUtil.GetQueue(MQUtil.CreateQueueName(), true);
mq.Formatter = new BinaryMessageFormatter();
Assert.IsTrue(mq.Transactional, "Message Queue should be transactional");
mq.Send(sent1, MessageQueueTransactionType.Single);
using (MessageQueueTransaction tx = new MessageQueueTransaction()) {
tx.Begin();
Message received1 = mq.Receive(new TimeSpan(0, 0, 2), tx);
tx.Commit();
Assert.AreEqual(body, received1.Body);
}
}
/// <summary>
/// Receives the first message available in the transactional queue
/// referenced by the MessageQueue matching the selection criteria,
/// and waits until either a message is available in the queue, or the
/// time-out expires.
/// </summary>
/// <param name="timeSpan">Reception time-out.</param>
/// <param name="transaction">Transaction.</param>
/// <returns>Received message.</returns>
public override IMessage Receive(TimeSpan timeSpan,
MessageQueueTransaction transaction)
{
try
{
// No time-out option for receiving messages by lookup identifiers:
// either the message is present in the queue, or the method throws
// an exception immediately if the message is not in the queue.
return(Convert(messageQueue.ReceiveByLookupId(
MessageLookupAction.Current, lookupId, transaction)));
}
catch (InvalidOperationException)
{
return(null);
}
catch (Exception ex)
{
throw ex;
}
}
public bool SendBatchTransactional(List <T> payloads, string lablel)
{
try
{
MessageQueueTransaction myTransaction = new MessageQueueTransaction();
myTransaction.Begin();
foreach (T payload in payloads)
{
_messageQueue.Send(payload, lablel, myTransaction);
}
myTransaction.Commit();
return(true);
}
catch (Exception)
{
return(false);
}
}
public static void WriteMessage(EndpointAddress destination, ChannelMessage channelMessage)
{
var queuePath = destination.GetQueuePath();
var destinationQueue = new MessageQueue(queuePath);
var queueMessage = new Message
{
BodyStream = channelMessage.BodyStream,
Label = channelMessage.Headers.First().Value,
Extension = ConvertHeaders(channelMessage)
};
using (var tx = new MessageQueueTransaction())
{
tx.Begin();
destinationQueue.Send(queueMessage, tx);
tx.Commit();
}
}
/// <summary>
/// Event Handler For Peek Completed.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></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();
FireRecieveEvent(message.Body);
}
catch
{
transaction.Abort();
}
}
static void Main(string[] args)
{
Top:
if (!CheckMSMQInstalled())
{
//installer will work
return;
}
MessageQueue messageQueue = null;
//Check msmq private path available or not
if (!MessageQueue.Exists(Path))
{
//Create message queue with transaction enabled
messageQueue = MessageQueue.Create(Path, true);
}
else
{
messageQueue = new MessageQueue(Path, QueueAccessMode.Send);
}
if (messageQueue.Transactional == true)
{
MessageQueueTransaction transaction = new MessageQueueTransaction();
transaction.Begin();
messageQueue.Send("Antony first send message to queue", transaction);
transaction.Commit();
messageQueue.Close();
}
Console.WriteLine("Send message type 1. For exit type 2.");
var options = Console.ReadLine();
if (Convert.ToInt32(options) == 1)
{
goto Top;
}
else
{
return;
}
}
/// <summary>
///
/// </summary>
/// <param name="message_queue"></param>
/// <param name="message"></param>
/// <param name="label"></param>
/// <param name="app_specific"></param>
/// <param name="priority"></param>
/// <returns></returns>
public bool WriteQueue(MessageQueue message_queue, object message, string label, int app_specific, MessagePriority priority)
{
var _result = false;
//if (message_queue.Transactional == true)
{
using (MessageQueueTransaction _qTransaction = new MessageQueueTransaction())
{
_qTransaction.Begin();
try
{
using (Message _message = new Message
{
Formatter = new XmlMessageFormatter(new Type[] { typeof(QMessage) }),
//Formatter = new BinaryMessageFormatter(),
Body = message,
Label = label,
AppSpecific = app_specific,
Priority = priority
})
{
message_queue.Send(_message, _qTransaction);
}
_qTransaction.Commit();
_result = true;
}
catch (MessageQueueException ex)
{
_qTransaction.Abort();
throw new Exception(ex.MessageQueueErrorCode.ToString(), ex);
}
catch (Exception)
{
}
}
}
return(_result);
}
private static void SendToMsmq()
{
// Open transactional MSMQ queue. Define filter to retrieve all message properties.
MessageQueue msmqQueue = Helper.OpenMsmqQueue(Constants.MsmqSendQueue, true);
Console.WriteLine("We will wait for 10 seconds between each 'Send' to clearly show the bridge functionality...");
Console.WriteLine();
for (int i = 1; i <= 3; i++)
{
var message = new System.Messaging.Message();
message.Body = "Message body " + i + ".";
message.Formatter = new BinaryMessageFormatter();
message.Label = "Message" + i;
// Send a message.
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(
string.Format("Sending Message to {0}: {1}", Constants.MsmqSendQueue, message.Label));
Console.ResetColor();
using (var tx = new MessageQueueTransaction())
{
tx.Begin();
try
{
msmqQueue.Send(message, tx);
tx.Commit();
}
catch (MessageQueueException exception)
{
Console.WriteLine("MessageQueueException received: " + exception.ToString());
throw;
}
}
// For the purpose of clearly showing the functionality of the bridge sample, sleep for 30seconds
// so that there is sufficient time between each message output
Thread.Sleep(10000);
}
}
private void Send()
{
if (System.Messaging.MessageQueue.Exists(this.Path))
{
if (string.IsNullOrEmpty(this.Label))
{
this.Label = string.Empty;
}
this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "Sending message to queue: [{0}] - {1}", this.Path, this.Message));
// Connect to a queue on the local computer.
using (System.Messaging.MessageQueue queue = new System.Messaging.MessageQueue(this.Path))
{
// Send a message to the queue.
if (this.Transactional)
{
// Create a transaction.
using (MessageQueueTransaction myTransaction = new MessageQueueTransaction())
{
// Begin the transaction.
myTransaction.Begin();
// Send the message.
queue.Send(this.Message, this.Label, myTransaction);
// Commit the transaction.
myTransaction.Commit();
}
}
else
{
queue.Send(this.Message, this.Label);
}
}
}
else
{
this.Log.LogError(string.Format(CultureInfo.CurrentCulture, "Queue not found: {0}", this.Path));
}
}
/* Code from https://msdn.microsoft.com/en-us/library/system.messaging.binarymessageformatter(v=vs.110).aspx
* Only changes made is in replacing hardcoded queue name with QUEUE_PATH, and converting queue to support transactions
*
* Exception will be thrown by casting in "Bitmap myImage = (Bitmap)myMessage.Body;"
*/
//**************************************************
// Receives a message containing an image.
//**************************************************
public static void ReceiveMessage()
{
try
{
MessageQueueTransaction transaction = new MessageQueueTransaction();
transaction.Begin();
// Connect to the a queue on the local computer.
MessageQueue myQueue = new MessageQueue(QUEUE_PATH, TRANSACTIONAL);
// Set the formatter to indicate body contains an Order.
myQueue.Formatter = new BinaryMessageFormatter();
// Receive and format the message.
System.Messaging.Message myMessage = myQueue.Receive();
transaction.Commit();
Bitmap myImage = (Bitmap)myMessage.Body;
// This will be saved in the \bin\debug or \bin\retail folder.
myImage.Save("ReceivedImage.bmp", System.Drawing.Imaging.ImageFormat.Bmp);
}
catch (MessageQueueException)
{
// Handle Message Queuing exceptions.
}
// Handle invalid serialization format.
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
catch (IOException e)
{
// Handle file access exceptions.
}
// Catch other exceptions as necessary.
return;
}
public static string SendMessage(string queueName, string remoteQueueIp, object message, string messageLabel)
{
try
{
MessageQueue queue;
MessageQueueTransaction msgTx = new MessageQueueTransaction();
Message msg = new Message();
string queuePath = string.Format(@"FORMATNAME:Direct=TCP:{0}\private$\{1}", remoteQueueIp, queueName);
queue = new MessageQueue(queuePath);
msg.Label = messageLabel;
msg.Formatter = new BinaryMessageFormatter();
msg.Body = message;
msg.UseJournalQueue = false;
msg.Recoverable = true;
msgTx.Begin();
try
{
queue.Send(msg, msgTx);
msgTx.Commit();
}
catch
{
msgTx.Abort();
}
finally
{
queue.Close();
}
return(msg.Id);
}
catch (Exception ex)
{
throw ex;
}
}
private void SendIternal(Object message, MessageQueue queue)
{
// Set the formatter to JSON.
queue.Formatter = new MsmqMessageFormatter();
// Since we're using a transactional queue, make a transaction.
using (MessageQueueTransaction mqt = new MessageQueueTransaction())
{
mqt.Begin();
// Create a simple text message.
Message myMessage = new Message(message, new MsmqMessageFormatter());
myMessage.Label = message.GetType().FullName;
myMessage.ResponseQueue = new MessageQueue(_configuration.InputQueue.GetQueueFormatName());
// Send the message.
queue.Send(myMessage, mqt);
mqt.Commit();
}
}
public void Send(string destinationQueueName, TransportMessageToSend message, ITransactionContext context)
{
var recipientPath = MsmqUtil.GetSenderPath(destinationQueueName);
if (!context.IsTransactional)
{
using (var outputQueue = GetMessageQueue(recipientPath))
using (var transaction = new MessageQueueTransaction())
{
transaction.Begin();
outputQueue.Send(message, transaction);
transaction.Commit();
}
return;
}
using (var outputQueue = GetMessageQueue(recipientPath))
{
outputQueue.Send(message, GetTransaction(context));
}
}
public void ReceiveWithTransactionAbort()
{
String body = "foo-" + DateTime.Now.ToString();
Message sent1 = new Message(body, new BinaryMessageFormatter());
MessageQueue mq = MQUtil.GetQueue(MQUtil.CreateQueueName(), true);
Assert.IsTrue(mq.Transactional, "Message Queue should be transactional");
mq.Send(sent1, MessageQueueTransactionType.Single);
using (MessageQueueTransaction tx = new MessageQueueTransaction()) {
tx.Begin();
Message received1 = mq.Receive(tx);
tx.Abort();
}
Message received2 = mq.Receive();
Assert.AreEqual(body, received2.Body);
}
/// <summary>
/// 添加一条记录[基本方法]
/// 异步时,会定时执行批量插入,依赖MSMQ服务
/// </summary>
/// <param name="p"></param>
/// <param name="asyn">异步插入</param>
public virtual void Add(TModel p, bool asyn = false)
{
AbsDBExtend db = DBExtend;
#region MQ初始
if (asyn)
{
IniteQueue();
if (queueInitStatus == 2)
{
db.CheckData(p);
var trans = new MessageQueueTransaction();
trans.Begin();
msmq.Send(p, queueLabel, trans);
trans.Commit();
return;
}
}
#endregion
db.InsertFromObj(p);
}
public void Send(Message message, MessageQueueTransaction transaction)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
try
{
if (_messageQueue == null)
{
Initialize();
}
_messageQueue.Send(message, transaction);
}
catch (Exception ex)
{
throw new QueueException("Unable to send message", ex);
}
}
public void ReceiveByCorrelationIdWithTransactionAndTimeout()
{
string correlationId = Guid.NewGuid() + "\\0";
String body = "foo-" + DateTime.Now.ToString();
Message sent1 = new Message(body, new BinaryMessageFormatter());
sent1.CorrelationId = correlationId;
MessageQueue mq = MQUtil.GetQueue(MQUtil.CreateQueueName(), true);
Assert.IsTrue(mq.Transactional, "Message Queue should be transactional");
mq.Send(sent1, MessageQueueTransactionType.Single);
string id = sent1.Id;
using (MessageQueueTransaction tx = new MessageQueueTransaction()) {
tx.Begin();
Message received1 = mq.ReceiveByCorrelationId(correlationId, new TimeSpan(0, 0, 2), tx);
tx.Commit();
Assert.AreEqual(body, received1.Body);
}
}
void DeleteMessage(Message message)
{
using (var queue = new MessageQueue(message.QueuePath))
using (var transaction = new MessageQueueTransaction())
{
transaction.Begin();
try
{
queue.ReceiveById(message.Id, transaction);
transaction.Commit();
}
catch
{
transaction.Abort();
throw;
}
}
Messenger.Default.Send(new MessageDeleted(message));
}
private void OnPeekCompleted(object sender, PeekCompletedEventArgs e)
{
_queue.EndPeek(e.AsyncResult);
MessageQueueTransaction messageQueueTransaction = new MessageQueueTransaction();
Message message;
try
{
messageQueueTransaction.Begin();
message = _queue.Receive(messageQueueTransaction);
messageQueueTransaction.Commit();
StartListening();
FireReceiveEvent(message.Body);
}
catch
{
messageQueueTransaction.Abort();
}
}
private void MoveToErrorQueue(Message message, Exception ex, MessageQueueTransaction messageQueueTransaction, int errorCount)
{
Log.ErrorFormat(
"Message {0} reached error count {1}, moving to error queue.",
message.Id,
errorCount);
// reset error count
message.AppSpecific = 0;
// place exception details in the extension property
message.Extension = Encoding.UTF8.GetBytes(ex.ToString());
// maximum length allowed is 249
string exceptionMessage = ex.Message;
message.Label = exceptionMessage.Substring(0, Math.Min(exceptionMessage.Length, 249));
// send message to error queue
_errorMessageQueue.Send(message, messageQueueTransaction);
}
static void Main(string[] args)
{
MessageQueue myQueue = new MessageQueue(QueueName);
if (myQueue.Transactional == true)
{
MessageQueueTransaction myTransaction = new MessageQueueTransaction();
myTransaction.Begin();
myQueue.Send(MyMsg, myTransaction);
myTransaction.Commit();
}
else
{
myQueue.Send(MyMsg, "label");
}
myQueue.Close();
}
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();
}
}
public void Enqueue_SendsTheJobId()
{
// Arrange
var queue = CreateQueue(MsmqTransactionType.Internal);
// Act
queue.Enqueue(_connection.Object, "my-queue", "job-id");
// Assert
using (var messageQueue = CleanMsmqQueueAttribute.GetMessageQueue("my-queue"))
using (var transaction = new MessageQueueTransaction())
{
transaction.Begin();
var message = messageQueue.Receive(TimeSpan.FromSeconds(5), transaction);
Assert.Equal("job-id", message.Label);
transaction.Commit();
}
}
public void Send(object obj, string label, MessageQueueTransaction transaction) {}
public void Send(object obj, MessageQueueTransaction transaction) {}
public Message ReceiveByLookupId(MessageLookupAction action, long lookupId, MessageQueueTransaction transaction) {}
public Message ReceiveByCorrelationId(string correlationId, System.TimeSpan timeout, MessageQueueTransaction transaction) {}
public Message ReceiveByCorrelationId(string correlationId, MessageQueueTransaction transaction) {}
public Message ReceiveById(string id, MessageQueueTransaction transaction) {}
public Message Receive(System.TimeSpan timeout, Cursor cursor, MessageQueueTransaction transaction) {}
public Message Receive(MessageQueueTransaction transaction) {}
public MSMQMessagingTransaction(MessageQueueTransaction transaction)
{
this.transaction = transaction;
this.shared = true;
}
public Message RemoveCurrent(MessageQueueTransaction transaction) {}
public Message ReceiveById(string id, System.TimeSpan timeout, MessageQueueTransaction transaction) {}
public Message RemoveCurrent(System.TimeSpan timeout, MessageQueueTransaction transaction) {}
