public Message Receive(MessageQueueTransactionType transactionType) { try { IMessage iMsg = delegateQueue.Receive((Mono.Messaging.MessageQueueTransactionType)transactionType); if (iMsg == null) { return(null); } return(new Message(iMsg, null, Formatter)); } catch (ConnectionException e) { throw new MessageQueueException(MessageQueueErrorCode.QueueNotAvailable, e.Message); } catch (MessageUnavailableException e) { throw new InvalidOperationException(e.Message, e); } catch (MonoMessagingException e) { throw new MessageQueueException(MessageQueueErrorCode.Generic, e.Message); } }
public string SendMessage(string message) { MessageQueue queueManager = null; System.Messaging.Message messageToSend = new System.Messaging.Message(); try { queueManager = new MessageQueue(queueTXT.Text); System.IO.StreamWriter streamWriter = new System.IO.StreamWriter(messageToSend.BodyStream, System.Text.Encoding.Unicode); streamWriter.Write(message); streamWriter.Flush(); MessageQueueTransactionType mqTT = (MessageQueueTransactionType)Enum.Parse(typeof(MessageQueueTransactionType), comboBox1.Text); queueManager.Send(messageToSend, msgLabelTXT.Text, mqTT); } catch (MessageQueueException ex) { throw; } finally { if (queueManager != null) { queueManager.Close(); } } return(messageToSend.Id); }
private IMessage Run (MessageQueueTransactionType transactionType, RecieveDelegate r) { switch (transactionType) { case MessageQueueTransactionType.Single: using (RabbitMQMessageQueueTransaction tx = GetTx ()) { bool success = false; try { IMessage msg = Run (tx, r); tx.Commit (); success = true; return msg; } finally { if (!success) tx.Abort (); } } case MessageQueueTransactionType.None: return Run (r); default: throw new NotSupportedException(transactionType + " not supported"); } }
public void Send(object obj, MessageQueueTransactionType transactionType) { if (typeof(Message) == obj.GetType()) { Message m = (Message)obj; if (m.BodyStream == null) { IMessageFormatter f = (m.Formatter == null) ? Formatter : m.Formatter; f.Write(m, m.Body); } try { delegateQueue.Send(m.DelegateMessage, (Mono.Messaging.MessageQueueTransactionType)transactionType); } catch (ConnectionException e) { throw new MessageQueueException(MessageQueueErrorCode.QueueNotAvailable, e.Message); } catch (MonoMessagingException e) { throw new MessageQueueException(MessageQueueErrorCode.Generic, e.Message); } } else { Message m = new Message(obj); Send(m, transactionType); } }
public void Send(IMessage msg, MessageQueueTransactionType transactionType) { switch (transactionType) { case MessageQueueTransactionType.Single: using (IMessageQueueTransaction tx = provider.CreateMessageQueueTransaction()) { try { Send(msg, tx); tx.Commit(); } catch (Exception e) { tx.Abort(); throw new MonoMessagingException(e.Message, e); } } break; case MessageQueueTransactionType.None: Send(msg); break; case MessageQueueTransactionType.Automatic: throw new NotSupportedException("Automatic transaction types not supported"); } }
public Message RemoveCurrent(TimeSpan timeout, MessageQueueTransactionType transactionType) { try { IMessage iMsg = delegateEnumerator.RemoveCurrent(timeout, (Mono.Messaging.MessageQueueTransactionType)transactionType); if (iMsg == null) { return(null); } return(new Message(iMsg, null, formatter)); } catch (ConnectionException e) { throw new MessageQueueException(MessageQueueErrorCode.QueueNotAvailable, e.Message); } catch (MessageUnavailableException e) { throw new InvalidOperationException(e.Message, e); } catch (MonoMessagingException e) { throw new MessageQueueException(MessageQueueErrorCode.Generic, e.Message); } }
private IMessage DoReceive(MessageQueueTransactionType transactionType, TimeSpan timeout, IsMatch matcher, bool ack) { switch (transactionType) { case MessageQueueTransactionType.Single: using (RabbitMQMessageQueueTransaction tx = NewTx()) { bool success = false; try { IMessage msg = DoReceive((IMessagingContext)tx, timeout, matcher, ack); tx.Commit(); success = true; return(msg); } finally { if (!success) { tx.Abort(); } } } case MessageQueueTransactionType.None: return(DoReceive(timeout, matcher, true)); default: throw new NotSupportedException(transactionType + " not supported"); } }
public MsmqMessageDeliveryQueue(string path, MessageQueueTransactionType transactionType, IMessageFormatter formatter) { _queue = new MessageQueue(path); _formatter = new MessageDeliveryFormatter(); _transactionType = transactionType; _formatter = formatter; }
public void Send(Message message, MessageQueueTransactionType transactionType) { this.message = message; this.transactionType = transactionType; numMessages++; }
/// <summary> /// Initializes a new instance of <see cref="MsmqTraceListener"/>. /// </summary> /// <param name="name">The name of the new instance.</param> /// <param name="queuePath">The path to the queue to deliver to.</param> /// <param name="formatter">The formatter to use.</param> /// <param name="messagePriority">The priority for the messages to send.</param> /// <param name="recoverable">The recoverable flag for the messages to send.</param> /// <param name="timeToReachQueue">The timeToReachQueue for the messages to send.</param> /// <param name="timeToBeReceived">The timeToBeReceived for the messages to send.</param> /// <param name="useAuthentication">The useAuthentication flag for the messages to send.</param> /// <param name="useDeadLetterQueue">The useDeadLetterQueue flag for the messages to send.</param> /// <param name="useEncryption">The useEncryption flag for the messages to send.</param> /// <param name="transactionType">The <see cref="MessageQueueTransactionType"/> for the message to send.</param> /// <param name="msmqInterfaceFactory">The factory to create the msmq interfaces.</param> public MsmqTraceListener(string name, string queuePath, ILogFormatter formatter, MessagePriority messagePriority, bool recoverable, TimeSpan timeToReachQueue, TimeSpan timeToBeReceived, bool useAuthentication, bool useDeadLetterQueue, bool useEncryption, MessageQueueTransactionType transactionType, IMsmqSendInterfaceFactory msmqInterfaceFactory) : base(formatter) { this.queuePath = queuePath; this.messagePriority = messagePriority; this.recoverable = recoverable; this.timeToReachQueue = timeToReachQueue; this.timeToBeReceived = timeToBeReceived; this.useAuthentication = useAuthentication; this.useDeadLetterQueue = useDeadLetterQueue; this.useEncryption = useEncryption; this.transactionType = transactionType; this.msmqInterfaceFactory = msmqInterfaceFactory; }
public static void ReturnMessageToSourceQueue(string errorQueueMachine, string errorQueueName, string msmqMessageId) { string path = string.Format(@"{0}\private$\{1}", errorQueueMachine, errorQueueName); MessageQueue errorQueue = new MessageQueue(path); { MessagePropertyFilter messageReadPropertyFilter = new MessagePropertyFilter { Body = true, TimeToBeReceived = true, Recoverable = true, Id = true, ResponseQueue = true, CorrelationId = true, Extension = true, AppSpecific = true, LookupId = true, }; errorQueue.MessageReadPropertyFilter = messageReadPropertyFilter; using (TransactionScope scope = new TransactionScope()) { MessageQueueTransactionType transactionType = MessageQueueTransactionType.Automatic; Message message = errorQueue.ReceiveById(msmqMessageId, TimeSpan.FromSeconds(5), transactionType); string fullPath = ReadFailedQueueHeader(message); using (MessageQueue failedQueue = new MessageQueue(fullPath)) { failedQueue.Send(message, transactionType); } scope.Complete(); } } }
public static bool ValidateMessageQueueTransactionType(MessageQueueTransactionType value) { if ((value != MessageQueueTransactionType.None) && (value != MessageQueueTransactionType.Automatic)) { return (value == MessageQueueTransactionType.Single); } return true; }
public static bool ValidateMessageQueueTransactionType(MessageQueueTransactionType value) { if ((value != MessageQueueTransactionType.None) && (value != MessageQueueTransactionType.Automatic)) { return(value == MessageQueueTransactionType.Single); } return(true); }
protected void MovePoisonMessageToErrorQueue(Message message, MessageQueueTransactionType transactionType) { var error = $"Message '{message.Id}' is classified as a poison message and will be moved to the configured error queue.'"; Logger.Error(error); errorQueue.Send(message, transactionType); }
public MsmqRouterFactory(ILoggerContextSensitive log, TimeSpan waitMessageTimeout, Func <MessageQueueTransactionType> sendTransactionType, MessageQueueTransactionType receiveTransactionType) { _stopwatch = new Stopwatch(); _log = log; _waitMessageTimeout = waitMessageTimeout; _sendTransactionType = sendTransactionType; _receiveTransactionType = receiveTransactionType; }
protected override void SendMessage(MessageQueue queue, Message message) { MessageQueueTransactionType tt = (Transaction.Current != null) ? MessageQueueTransactionType.Automatic : MessageQueueTransactionType.Single; queue.Send(message, tt); }
public Message Receive(TimeSpan fromSeconds, MessageQueueTransactionType transactionTypeForReceive) { var message = _messages.First(); _messages.Remove(message); _processedMessages.Add(message); return(message); }
public Message RemoveCurrent(TimeSpan timeout, MessageQueueTransactionType transactionType) { if (!ValidationUtility.ValidateMessageQueueTransactionType(transactionType)) { throw new InvalidEnumArgumentException("transactionType", (int)transactionType, typeof(MessageQueueTransactionType)); } return(this.RemoveCurrent(timeout, null, transactionType)); }
/// <include file='doc\MessageEnumerator.uex' path='docs/doc[@for="MessageEnumerator.RemoveCurrent4"]/*' /> /// <devdoc> /// <para> Removes the current message from /// the queue and returns the message to the calling application within the timeout specified.</para> /// </devdoc> public Message RemoveCurrent(TimeSpan timeout, MessageQueueTransactionType transactionType) { if (!Enum.IsDefined(typeof(MessageQueueTransactionType), transactionType)) { throw new InvalidEnumArgumentException("transactionType", (int)transactionType, typeof(MessageQueueTransactionType)); } return(RemoveCurrent(timeout, null, transactionType)); }
/// <summary> /// Initializes a new instance of the <see cref="MsmqTraceListenerData"/> class. /// </summary> /// <param name="name">The name for the represented trace listener.</param> /// <param name="queuePath">The path name for the represented trace listener.</param> /// <param name="formatterName">The formatter name for the represented trace listener.</param> /// <param name="messagePriority">The priority for the represented trace listener.</param> /// <param name="recoverable">The recoverable flag for the represented trace listener.</param> /// <param name="timeToReachQueue">The timeToReachQueue for the represented trace listener.</param> /// <param name="timeToBeReceived">The timeToReachQueue for the represented trace listener.</param> /// <param name="useAuthentication">The use authentication flag for the represented trace listener.</param> /// <param name="useDeadLetterQueue">The use dead letter flag for the represented trace listener.</param> /// <param name="useEncryption">The use encryption flag for the represented trace listener.</param> /// <param name="transactionType">The transaction type for the represented trace listener.</param> public MsmqTraceListenerData(string name, string queuePath, string formatterName, MessagePriority messagePriority, bool recoverable, TimeSpan timeToReachQueue, TimeSpan timeToBeReceived, bool useAuthentication, bool useDeadLetterQueue, bool useEncryption, MessageQueueTransactionType transactionType) : this(name, queuePath, formatterName, messagePriority, recoverable, timeToReachQueue, timeToBeReceived, useAuthentication, useDeadLetterQueue, useEncryption, transactionType, TraceOptions.None) { }
public static bool ValidateMessageQueueTransactionType(MessageQueueTransactionType value) { // // note that MessageQueueTransactionType has disjoined values // return (value == MessageQueueTransactionType.None) || (value == MessageQueueTransactionType.Automatic) || (value == MessageQueueTransactionType.Single); }
public static bool ValidateMessageQueueTransactionType(MessageQueueTransactionType value) { // // note that MessageQueueTransactionType has disjoined values // return((value == MessageQueueTransactionType.None) || (value == MessageQueueTransactionType.Automatic) || (value == MessageQueueTransactionType.Single)); }
public void Send(Message message, string label, MessageQueueTransactionType transactionType) { _queue.Send(message, label, transactionType); if (_autoPurgeSystemJournal && (_lastPurgedOn == DateTime.MinValue || _lastPurgedOn.AddMinutes(purgeIntervalInMinutes) < DateTime.Now)) { systemJournalQueue.Purge(); _lastPurgedOn = DateTime.Now; } }
/// <summary> /// Initializes a new instance of <see cref="MsmqTraceListener"/>. /// </summary> /// <param name="name">The name of the new instance.</param> /// <param name="queuePath">The path to the queue to deliver to.</param> /// <param name="formater">The formatter to use.</param> /// <param name="messagePriority">The priority for the messages to send.</param> /// <param name="recoverable">The recoverable flag for the messages to send.</param> /// <param name="timeToReachQueue">The timeToReachQueue for the messages to send.</param> /// <param name="timeToBeReceived">The timeToBeReceived for the messages to send.</param> /// <param name="useAuthentication">The useAuthentication flag for the messages to send.</param> /// <param name="useDeadLetterQueue">The useDeadLetterQueue flag for the messages to send.</param> /// <param name="useEncryption">The useEncryption flag for the messages to send.</param> /// <param name="transactionType">The <see cref="MessageQueueTransactionType"/> for the message to send.</param> public MsmqTraceListener(string name, string queuePath, ILogFormatter formater, MessagePriority messagePriority, bool recoverable, TimeSpan timeToReachQueue, TimeSpan timeToBeReceived, bool useAuthentication, bool useDeadLetterQueue, bool useEncryption, MessageQueueTransactionType transactionType) : this(name, queuePath, formater, messagePriority, recoverable, timeToReachQueue, timeToBeReceived, useAuthentication, useDeadLetterQueue, useEncryption, transactionType, new MsmqSendInterfaceFactory()) { }
public static void PushTripStatus(string TripID, EventDef aEvent) { MessageQueue queue = GetQueue(TripQueue, QueueAccessMode.Send); MessageQueueTransactionType txnType = MessageQueueTransactionType.Single; MQBatchRequest mqBatchRequest = new MQBatchRequest() { EventType = aEvent, MessageData = TripID, QueueTarget = TripQueue }; queue.Send(mqBatchRequest, txnType); }
public void Send(object obj, string label, MessageQueueTransactionType transactionType) { if (typeof(Message) == obj.GetType()) { Message m = (Message)obj; m.Label = label; Send(m, transactionType); } else { Message m = new Message(obj); Send(m, label, transactionType); } }
private void SendMsmqMesage(string serializedEntry) { lock (syncObject) { using (MessageQueue messageQueue = new MessageQueue(msmqDistributionStrategyData.QueuePath)) { MessageQueueTransactionType transactionType = (messageQueue.Transactional) ? MessageQueueTransactionType.Single : MessageQueueTransactionType.None; messageQueue.Formatter = new XmlMessageFormatter(); messageQueue.Send(serializedEntry, transactionType); messageQueue.Close(); } } }
/// <summary> /// ITestStep.Execute() implementation /// </summary> /// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param> /// <param name='context'>The context for the test, this holds state that is passed beteen tests</param> public void Execute(XmlNode testConfig, Context context) { MemoryStream msgStr = null; try { // read test config... string sourcePath = context.ReadConfigAsString(testConfig, "SourcePath"); string queuePath = context.ReadConfigAsString(testConfig, "QueuePath"); string messageLabel = context.ReadConfigAsString(testConfig, "MessageLabel"); string correlationId = context.ReadConfigAsString(testConfig, "CorrelationId", true); int appSpecific = context.ReadConfigAsInt32(testConfig, "AppSpecific", true); object objUseTransactions = context.ReadConfigAsObject(testConfig, "UseTransactions", true); if (null != objUseTransactions) { if (!Convert.ToBoolean(objUseTransactions)) { _transactionType = MessageQueueTransactionType.None; } } context.LogInfo("MSMQWriteStep about to write data from File: {0} to the queue: {1}", sourcePath, queuePath); var queue = new MessageQueue(queuePath); var msg = new Message(); msgStr = StreamHelper.LoadFileToStream(sourcePath); msg.BodyStream = msgStr; msg.UseDeadLetterQueue = true; if (null != correlationId) { msg.CorrelationId = correlationId; } msg.AppSpecific = appSpecific; queue.Send(msg, messageLabel, _transactionType); } finally { if (null != msgStr) { msgStr.Close(); } } }
public override void Execute(Context context) { _request = MessageBody.Load(context); context.LogXmlData("Message", _request, true); try { if (!UseTransactions) { _transactionType = MessageQueueTransactionType.None; } context.LogInfo("MSMQWriteStep about to write data to the queue: {0}", QueuePath); var queue = new MessageQueue(MSMQHelper.DeNormalizeQueueName(QueuePath)); var msg = new Message(); if (BodyType == VarEnum.VT_EMPTY) { msg.BodyStream = _request; } else { msg.BodyType = (int)BodyType; var formatter = new ActiveXMessageFormatter(); formatter.Write(msg, Common.StreamHelper.WriteStreamToString(_request)); } msg.UseDeadLetterQueue = true; if (!string.IsNullOrEmpty(CorrelationId)) { msg.CorrelationId = CorrelationId; } msg.AppSpecific = AppSpecific; queue.Send(msg, MessageLabel, _transactionType); } finally { if (null != _request) { _request.Close(); } } }
public static void PushTripInfo(string TripID, int EmployeeID, EventDef aEvent) { MessageQueue queue = GetQueue(TripQueue, QueueAccessMode.Send); MessageQueueTransactionType txnType = MessageQueueTransactionType.Single; MQBatchRequest mqBatchRequest = new MQBatchRequest() { EventType = aEvent, MessageData = new TripPersonUpdate() { TripID = TripID, EmployeeID = EmployeeID }, QueueTarget = TripQueue }; queue.Send(mqBatchRequest, txnType); }
/// <summary> /// Initialize a new instance of the <see cref="MsmqTraceListenerNode"/> class with a <see cref="MsmqTraceListenerData"/> instance. /// </summary> /// <param name="msmqTraceListenerData">A <see cref="MsmqTraceListenerData"/> instance.</param> public MsmqTraceListenerNode(MsmqTraceListenerData msmqTraceListenerData) { if (null == msmqTraceListenerData) throw new ArgumentNullException("msmqTraceListenerData"); Rename(msmqTraceListenerData.Name); TraceOutputOptions = msmqTraceListenerData.TraceOutputOptions; this.useEncryption = msmqTraceListenerData.UseEncryption; this.useDeadLetterQueue = msmqTraceListenerData.UseDeadLetterQueue; this.useAuthentication = msmqTraceListenerData.UseAuthentication; this.transactionType = msmqTraceListenerData.TransactionType; this.messagePriority = msmqTraceListenerData.MessagePriority; this.timeToReachQueue = msmqTraceListenerData.TimeToReachQueue; this.timeToBeReceived = msmqTraceListenerData.TimeToBeReceived; this.recoverable = msmqTraceListenerData.Recoverable; this.queuePath = msmqTraceListenerData.QueuePath; this.formatterName = msmqTraceListenerData.Formatter; }
/// <summary> /// Initializes a new instance of the <see cref="MsmqTraceListenerData"/> class. /// </summary> /// <param name="name">The name for the represented trace listener.</param> /// <param name="queuePath">The path name for the represented trace listener.</param> /// <param name="formatterName">The formatter name for the represented trace listener.</param> /// <param name="messagePriority">The priority for the represented trace listener.</param> /// <param name="recoverable">The recoverable flag for the represented trace listener.</param> /// <param name="timeToReachQueue">The timeToReachQueue for the represented trace listener.</param> /// <param name="timeToBeReceived">The timeToReachQueue for the represented trace listener.</param> /// <param name="useAuthentication">The use authentication flag for the represented trace listener.</param> /// <param name="useDeadLetterQueue">The use dead letter flag for the represented trace listener.</param> /// <param name="useEncryption">The use encryption flag for the represented trace listener.</param> /// <param name="transactionType">The transaction type for the represented trace listener.</param> /// <param name="traceOutputOptions">The trace output options for the represented trace listener.</param> public MsmqTraceListenerData(string name, string queuePath, string formatterName, MessagePriority messagePriority, bool recoverable, TimeSpan timeToReachQueue, TimeSpan timeToBeReceived, bool useAuthentication, bool useDeadLetterQueue, bool useEncryption, MessageQueueTransactionType transactionType, TraceOptions traceOutputOptions) : base(name, typeof(MsmqTraceListener), traceOutputOptions) { this.QueuePath = queuePath; this.Formatter = formatterName; this.MessagePriority = messagePriority; this.Recoverable = recoverable; this.TimeToReachQueue = timeToReachQueue; this.TimeToBeReceived = timeToBeReceived; this.UseAuthentication = useAuthentication; this.UseDeadLetterQueue = useDeadLetterQueue; this.UseEncryption = useEncryption; this.TransactionType = transactionType; }
public static void Queue(BatchRequest batchRequest) { try { MessageQueue queue = GetQueue(batchRequest.QueueTarget, QueueAccessMode.Send); MessageQueueTransactionType txnType = MessageQueueTransactionType.Single; if (queue.CanWrite == false) { throw new Exception("PhysicalQueueNotFound: " + batchRequest.QueueTarget); } queue.Send(batchRequest, txnType); } catch (Exception ex) { throw ex; } }
/// <summary> /// Initializes a new instance of <see cref="MsmqTraceListener"/>. /// </summary> /// <param name="name">The name of the new instance.</param> /// <param name="queuePath">The path to the queue to deliver to.</param> /// <param name="formater">The formatter to use.</param> /// <param name="messagePriority">The priority for the messages to send.</param> /// <param name="recoverable">The recoverable flag for the messages to send.</param> /// <param name="timeToReachQueue">The timeToReachQueue for the messages to send.</param> /// <param name="timeToBeReceived">The timeToBeReceived for the messages to send.</param> /// <param name="useAuthentication">The useAuthentication flag for the messages to send.</param> /// <param name="useDeadLetterQueue">The useDeadLetterQueue flag for the messages to send.</param> /// <param name="useEncryption">The useEncryption flag for the messages to send.</param> /// <param name="transactionType">The <see cref="MessageQueueTransactionType"/> for the message to send.</param> /// <param name="msmqInterfaceFactory">The factory to create the msmq interfaces.</param> public MsmqTraceListener(string name, string queuePath, ILogFormatter formater, MessagePriority messagePriority, bool recoverable, TimeSpan timeToReachQueue, TimeSpan timeToBeReceived, bool useAuthentication, bool useDeadLetterQueue, bool useEncryption, MessageQueueTransactionType transactionType, IMsmqSendInterfaceFactory msmqInterfaceFactory) : base(formater) { this.queuePath = queuePath; this.messagePriority = messagePriority; this.recoverable = recoverable; this.timeToReachQueue = timeToReachQueue; this.timeToBeReceived = timeToBeReceived; this.useAuthentication = useAuthentication; this.useDeadLetterQueue = useDeadLetterQueue; this.useEncryption = useEncryption; this.transactionType = transactionType; this.msmqInterfaceFactory = msmqInterfaceFactory; }
protected bool TryReceive(MessageQueueTransactionType transactionType, out Message message) { try { message = inputQueue.Receive(TimeSpan.FromMilliseconds(10), transactionType); return true; } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout) { //We should only get an IOTimeout exception here if another process removed the message between us peeking and now. message = null; return false; } throw; } }
public void Send (object obj, MessageQueueTransactionType transactionType) { if (typeof (Message) == obj.GetType ()) { Message m = (Message) obj; if (m.BodyStream == null) { IMessageFormatter f = (m.Formatter == null) ? Formatter : m.Formatter; f.Write (m, m.Body); } try { delegateQueue.Send (m.DelegateMessage, (Mono.Messaging.MessageQueueTransactionType) transactionType); } catch (ConnectionException e) { throw new MessageQueueException (MessageQueueErrorCode.QueueNotAvailable, e.Message); } catch (MonoMessagingException e) { throw new MessageQueueException (MessageQueueErrorCode.Generic, e.Message); } } else { Message m = new Message (obj); Send (m, transactionType); } }
public void Send(object obj, string label, MessageQueueTransactionType transactionType) {}
/// <summary> /// Receives the current message in the queue, using a specified cursor. If no message is available, this method waits until either a message is available, or the time-out expires. /// </summary> /// <returns> /// A <see cref="T:System.Messaging.Message"/> that references a message in the queue. /// </returns> /// <param name="timeout">A <see cref="T:System.TimeSpan"/> that indicates the time to wait until a new message is available for inspection. </param><param name="cursor">A <see cref="T:System.Messaging.Cursor"/> that maintains a specific position in the message queue.</param><param name="transactionType">One of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> values that describes the type of transaction context to associate with the message. </param><exception cref="T:System.ArgumentNullException">The <paramref name="cursor"/> parameter is null.</exception><exception cref="T:System.ArgumentException">The value specified for the <paramref name="timeout"/> parameter is not valid. Possibly <paramref name="timeout"/> is less than <see cref="F:System.TimeSpan.Zero"/> or greater than <see cref="F:System.Messaging.MessageQueue.InfiniteTimeout"/>. </exception><exception cref="T:System.ComponentModel.InvalidEnumArgumentException">The <paramref name="transactionType"/> parameter is not one of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> members. </exception><exception cref="T:System.Messaging.MessageQueueException">A message did not arrive in the queue before the time-out expired.-or- An error occurred when accessing a Message Queuing method. </exception> public Message Receive(TimeSpan timeout, Cursor cursor, MessageQueueTransactionType transactionType) { return _queue.Receive(timeout, cursor, transactionType); }
public void Send(object obj, MessageQueueTransactionType transactionType) {}
public Message ReceiveByCorrelationId(string correlationId, MessageQueueTransactionType transactionType) {}
/// <summary> /// Sends a message to the underlying MSMQ. /// </summary> /// <param name="message">The <see cref="Message"/> to send.</param> /// <param name="transactionType">The <see cref="MessageQueueTransactionType"/> value that specifies the type of transaciton to use.</param> public void Send(Message message, MessageQueueTransactionType transactionType) { messageQueue.Send(message, transactionType); }
/// <summary> /// Initializes a new instance of the <see cref="MsmqTraceListenerData"/> class. /// </summary> /// <param name="name">The name for the represented trace listener.</param> /// <param name="queuePath">The path name for the represented trace listener.</param> /// <param name="formatterName">The formatter name for the represented trace listener.</param> /// <param name="messagePriority">The priority for the represented trace listener.</param> /// <param name="recoverable">The recoverable flag for the represented trace listener.</param> /// <param name="timeToReachQueue">The timeToReachQueue for the represented trace listener.</param> /// <param name="timeToBeReceived">The timeToReachQueue for the represented trace listener.</param> /// <param name="useAuthentication">The use authentication flag for the represented trace listener.</param> /// <param name="useDeadLetterQueue">The use dead letter flag for the represented trace listener.</param> /// <param name="useEncryption">The use encryption flag for the represented trace listener.</param> /// <param name="transactionType">The transaction type for the represented trace listener.</param> public MsmqTraceListenerData(string name, string queuePath, string formatterName, MessagePriority messagePriority, bool recoverable, TimeSpan timeToReachQueue, TimeSpan timeToBeReceived, bool useAuthentication, bool useDeadLetterQueue, bool useEncryption, MessageQueueTransactionType transactionType) : this(name, queuePath, formatterName, messagePriority, recoverable, timeToReachQueue, timeToBeReceived, useAuthentication, useDeadLetterQueue, useEncryption, transactionType, TraceOptions.None, SourceLevels.All) { }
/// <summary> /// Receives the message that matches the given identifier and waits until either a message with the specified identifier is available in the queue or the time-out expires. /// </summary> /// <returns> /// The <see cref="T:System.Messaging.Message"/> whose <see cref="P:System.Messaging.Message.Id"/> property matches the <paramref name="id"/> parameter passed in. /// </returns> /// <param name="id">The <see cref="P:System.Messaging.Message.Id"/> of the message to receive. </param><param name="timeout">A <see cref="T:System.TimeSpan"/> that indicates the time to wait until a new message is available for inspection. </param><param name="transactionType">One of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> values, describing the type of transaction context to associate with the message. </param><exception cref="T:System.ArgumentNullException">The <paramref name="id"/> parameter is null. </exception><exception cref="T:System.ArgumentException">The value specified for the <paramref name="timeout"/> parameter is not valid, possibly <paramref name="timeout"/> is less than <see cref="F:System.TimeSpan.Zero"/> or greater than <see cref="F:System.Messaging.MessageQueue.InfiniteTimeout"/>. </exception><exception cref="T:System.Messaging.MessageQueueException">A message with the specified <paramref name="id"/> did not arrive in the queue before the time-out expired.-or- An error occurred when accessing a Message Queuing method. </exception><exception cref="T:System.ComponentModel.InvalidEnumArgumentException">The <paramref name="transactionType"/> parameter is not one of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> members. </exception><PermissionSet><IPermission class="System.Security.Permissions.EnvironmentPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode, ControlEvidence"/><IPermission class="System.Messaging.MessageQueuePermission, System.Messaging, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" version="1" Unrestricted="true"/><IPermission class="System.Diagnostics.PerformanceCounterPermission, System, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/></PermissionSet> public Message ReceiveById(string id, TimeSpan timeout, MessageQueueTransactionType transactionType) { return _queue.ReceiveById(id, timeout, transactionType); }
/// <summary> /// Introduced in MSMQ 3.0. Receives a specific message from the queue, using the specified transaction context. The message can be specified by a lookup identifier or by its position at the front or end of the queue. /// </summary> /// <returns> /// The <see cref="T:System.Messaging.Message"/> specified by the <paramref name="action"/> and <paramref name="lookupId"/> parameters passed in. /// </returns> /// <param name="action">One of the <see cref="T:System.Messaging.MessageLookupAction"/> values, specifying how the message is read in the queue. Specify one of the following:MessageLookupAction.Current: Receives the message specified by <paramref name="lookupId"/> and removes it from the queue.MessageLookupAction.Next: Receives the message following the message specified by <paramref name="lookupId"/> and removes it from the queue.MessageLookupAction.Previous: Receives the message preceding the message specified by <paramref name="lookupId"/> and removes it from the queue.MessageLookupAction.First: Receives the first message in the queue and removes it from the queue. The <paramref name="lookupId"/> parameter must be set to 0.MessageLookupAction.Last: Receives the last message in the queue and removes it from the queue. The <paramref name="lookupId"/> parameter must be set to 0.</param><param name="lookupId">The <see cref="P:System.Messaging.Message.LookupId"/> of the message to receive, or 0. 0 is used when accessing the first or last message in the queue. </param><param name="transactionType">One of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> values, describing the type of transaction context to associate with the message.</param><exception cref="T:System.PlatformNotSupportedException">MSMQ 3.0 is not installed.</exception><exception cref="T:System.InvalidOperationException">The message with the specified <paramref name="lookupId"/> could not be found. </exception><exception cref="T:System.Messaging.MessageQueueException">An error occurred when accessing a Message Queuing method. </exception><exception cref="T:System.ComponentModel.InvalidEnumArgumentException">The <paramref name="action"/> parameter is not one of the <see cref="T:System.Messaging.MessageLookupAction"/> members.-or- The <paramref name="transactionType"/> parameter is not one of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> members.</exception> public Message ReceiveByLookupId(MessageLookupAction action, long lookupId, MessageQueueTransactionType transactionType) { return _queue.ReceiveByLookupId(action, lookupId, transactionType); }
public Message Receive(MessageQueueTransactionType transactionType) {}
/// <summary> /// Receives the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires. /// </summary> /// <returns> /// The <see cref="T:System.Messaging.Message"/> whose <see cref="P:System.Messaging.Message.CorrelationId"/> matches the <paramref name="correlationId"/> parameter passed in. /// </returns> /// <param name="correlationId">The <see cref="P:System.Messaging.Message.CorrelationId"/> of the message to receive. </param><param name="timeout">A <see cref="T:System.TimeSpan"/> that indicates the time to wait until a new message is available for inspection. </param><param name="transactionType">One of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> values, describing the type of transaction context to associate with the message. </param><exception cref="T:System.ArgumentNullException">The <paramref name="correlationId"/> parameter is null. </exception><exception cref="T:System.InvalidOperationException">The message with the specified <paramref name="correlationId"/> could not be found. </exception><exception cref="T:System.ArgumentException">The value specified for the <paramref name="timeout"/> parameter is not valid, possibly <paramref name="timeout"/> is less than <see cref="F:System.TimeSpan.Zero"/> or greater than <see cref="F:System.Messaging.MessageQueue.InfiniteTimeout"/>. </exception><exception cref="T:System.ComponentModel.InvalidEnumArgumentException">The <paramref name="transactionType"/> parameter is not one of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> members. </exception><exception cref="T:System.Messaging.MessageQueueException">The message with the specified <paramref name="correlationId"/> does not exist in the queue and did not arrive before the time-out expired.-or- An error occurred when accessing a Message Queuing method. </exception><PermissionSet><IPermission class="System.Security.Permissions.EnvironmentPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode, ControlEvidence"/><IPermission class="System.Messaging.MessageQueuePermission, System.Messaging, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" version="1" Unrestricted="true"/><IPermission class="System.Diagnostics.PerformanceCounterPermission, System, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/></PermissionSet> public Message ReceiveByCorrelationId(string correlationId, TimeSpan timeout, MessageQueueTransactionType transactionType) { return _queue.ReceiveByCorrelationId(correlationId, timeout, transactionType); }
public void Send (object obj, string label, MessageQueueTransactionType transactionType) { if (typeof (Message) == obj.GetType ()) { Message m = (Message) obj; m.Label = label; Send (m, transactionType); } else { Message m = new Message (obj); Send (m, label, transactionType); } }
public Message ReceiveByCorrelationId(string correlationId, System.TimeSpan timeout, MessageQueueTransactionType transactionType) {}
public Message ReceiveById (string id, TimeSpan timeout, MessageQueueTransactionType transactionType) { try { IMessage iMsg = delegateQueue.ReceiveById (id, timeout, (Mono.Messaging.MessageQueueTransactionType) transactionType); if (iMsg == null) return null; return new Message (iMsg, null, Formatter); } catch (ConnectionException e) { throw new MessageQueueException (MessageQueueErrorCode.QueueNotAvailable, e.Message); } catch (MessageUnavailableException e) { throw new InvalidOperationException (e.Message, e); } catch (MonoMessagingException e) { throw new MessageQueueException (MessageQueueErrorCode.Generic, e.Message); } }
public Message ReceiveByLookupId(MessageLookupAction action, long lookupId, MessageQueueTransactionType transactionType) {}
public Message Receive(System.TimeSpan timeout, Cursor cursor, MessageQueueTransactionType transactionType) {}
/// <summary> /// Receives the first message available in the queue referenced by the <see cref="T:System.Messaging.MessageQueue"/>. This call is synchronous, and blocks the current thread of execution until a message is available. /// </summary> /// <returns> /// A <see cref="T:System.Messaging.Message"/> that references the first message available in the queue. /// </returns> /// <param name="transactionType">One of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> values, describing the type of transaction context to associate with the message. </param><exception cref="T:System.Messaging.MessageQueueException">An error occurred when accessing a Message Queuing method. </exception><exception cref="T:System.ComponentModel.InvalidEnumArgumentException">The <paramref name="transactionType"/> parameter is not one of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> members. </exception><PermissionSet><IPermission class="System.Security.Permissions.EnvironmentPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode, ControlEvidence"/><IPermission class="System.Messaging.MessageQueuePermission, System.Messaging, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" version="1" Unrestricted="true"/><IPermission class="System.Diagnostics.PerformanceCounterPermission, System, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/></PermissionSet> public Message Receive(MessageQueueTransactionType transactionType) { return _queue.Receive(transactionType); }
public Message ReceiveById(string id, MessageQueueTransactionType transactionType) {}
public Message ReceiveById(string id, System.TimeSpan timeout, MessageQueueTransactionType transactionType) {}
/// <summary> /// Initializes a new instance of the <see cref="MsmqTraceListenerData"/> class. /// </summary> /// <param name="name">The name for the represented trace listener.</param> /// <param name="queuePath">The path name for the represented trace listener.</param> /// <param name="formatterName">The formatter name for the represented trace listener.</param> /// <param name="messagePriority">The priority for the represented trace listener.</param> /// <param name="recoverable">The recoverable flag for the represented trace listener.</param> /// <param name="timeToReachQueue">The timeToReachQueue for the represented trace listener.</param> /// <param name="timeToBeReceived">The timeToReachQueue for the represented trace listener.</param> /// <param name="useAuthentication">The use authentication flag for the represented trace listener.</param> /// <param name="useDeadLetterQueue">The use dead letter flag for the represented trace listener.</param> /// <param name="useEncryption">The use encryption flag for the represented trace listener.</param> /// <param name="transactionType">The transaction type for the represented trace listener.</param> /// <param name="traceOutputOptions">The trace output options for the represented trace listener.</param> /// <param name="filter">The filter for the represented trace listener.</param> public MsmqTraceListenerData(string name, string queuePath, string formatterName, MessagePriority messagePriority, bool recoverable, TimeSpan timeToReachQueue, TimeSpan timeToBeReceived, bool useAuthentication, bool useDeadLetterQueue, bool useEncryption, MessageQueueTransactionType transactionType, TraceOptions traceOutputOptions, SourceLevels filter) : base(name, typeof(MsmqTraceListener), traceOutputOptions, filter) { this.QueuePath = queuePath; this.Formatter = formatterName; this.MessagePriority = messagePriority; this.Recoverable = recoverable; this.TimeToReachQueue = timeToReachQueue; this.TimeToBeReceived = timeToBeReceived; this.UseAuthentication = useAuthentication; this.UseDeadLetterQueue = useDeadLetterQueue; this.UseEncryption = useEncryption; this.TransactionType = transactionType; }
public IMessage ReceiveByCorrelationId (string id, TimeSpan timeout, MessageQueueTransactionType transactionType) { return Run (transactionType, Receiver (timeout, ByCorrelationId (id))); }