C# MessageQueueTransactionType类代码示例

 public MsmqMessageDeliveryQueue(string path, MessageQueueTransactionType transactionType, IMessageFormatter formatter)
 {
     _queue = new MessageQueue(path);
     _formatter = new MessageDeliveryFormatter();
     _transactionType = transactionType;
     _formatter = formatter;
 }

 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)
 {
     //
     // note that MessageQueueTransactionType has disjoined values
     //
     return (value == MessageQueueTransactionType.None) ||
            (value == MessageQueueTransactionType.Automatic) ||
            (value == MessageQueueTransactionType.Single);
 }

        /// <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())
        {
        }

        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;
            }
        }

		/// <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;
		}

 /// <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)
 {
 }

		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 void Send(Message message, MessageQueueTransactionType transactionType)
 {
     this.message = message;
     this.transactionType = transactionType;
     numMessages++;
 }

	public void Send(object obj, MessageQueueTransactionType transactionType) {}

	public Message ReceiveByCorrelationId(string correlationId, System.TimeSpan timeout, MessageQueueTransactionType transactionType) {}

	public Message ReceiveById(string id, System.TimeSpan timeout, MessageQueueTransactionType transactionType) {}

		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 IMessage ReceiveByCorrelationId (string id, TimeSpan timeout,
		                                        MessageQueueTransactionType transactionType)
		{
			return Run (transactionType, Receiver (timeout, ByCorrelationId (id)));
		}

	public Message Receive(System.TimeSpan timeout, Cursor cursor, MessageQueueTransactionType transactionType) {}