C# IMessageConsumer.Receive方法代码示例

 /// <summary>
 /// Consumes n messages, checking that the n+1th is not available within a timeout, and that the consumed messages
 /// are text messages with contents equal to the specified message body.
 /// </summary>
 ///
 /// <param name="n">The number of messages to consume.</param>
 /// <param name="body">The body text to match against all messages.</param>
 /// <param name="consumer">The message consumer to recieve the messages on.</param>
 public static void ConsumeNMessages(int n, string body, IMessageConsumer consumer)
 {
     IMessage msg;
     
     // Try to receive n messages.
     for (int i = 0; i < n; i++)
     {
         msg = consumer.Receive(RECEIVE_WAIT);
         Assert.IsNotNull(msg, "Consumer did not receive message number: " + i);
         Assert.AreEqual(body, ((ITextMessage)msg).Text, "Incorrect Message recevied on consumer1.");
     }
 }

        public void TestCloseConsumerBeforeCommit()
        {
            ITextMessage[] outbound = new ITextMessage[] {
                session.CreateTextMessage("First IMessage"),
                session.CreateTextMessage("Second IMessage")};

            // lets consume any outstanding messages from prev test runs
            BeginTx();
            bool needCommit = false;
            while(consumer.ReceiveNoWait() != null)
            {
                needCommit = true;
            }

            if(needCommit)
            {
                CommitTx();
            }

            // sends the messages
            BeginTx();
            producer.Send(outbound[0]);
            producer.Send(outbound[1]);
            CommitTx();

            BeginTx();
            ITextMessage message = (ITextMessage)consumer.Receive(TimeSpan.FromMilliseconds(1000));
            Assert.AreEqual(outbound[0].Text, message.Text);
            // Close the consumer before the Commit. This should not cause the
            // received message to Rollback.
            consumer.Close();
            CommitTx();

            // Create a new consumer
            consumer = CreateMessageConsumer();

            BeginTx();
            message = (ITextMessage)consumer.Receive(TimeSpan.FromMilliseconds(1000));
            Assert.IsNotNull(message);
            Assert.AreEqual(outbound[1].Text, message.Text);
            CommitTx();
        }

 /// <summary>
 /// Consumes n messages, checking that the n+1th is not available within a timeout, and that the consumed messages
 /// are text messages with contents equal to the specified message body.
 /// </summary>
 ///
 /// <param name="n">The number of messages to consume.</param>
 /// <param name="body">The body text to match against all messages.</param>
 /// <param name="consumer">The message consumer to recieve the messages on.</param>
 public static void ConsumeNMessagesOnly(int n, string body, IMessageConsumer consumer)
 {
     ConsumeNMessages(n, body, consumer);
     
     // Check that one more than n cannot be received.
     IMessage msg = consumer.Receive(RECEIVE_WAIT);
     Assert.IsNull(msg, "Consumer got more messages than the number requested (" + n + ").");
 }

 /// <summary>
 /// Receive a message.
 /// </summary>
 /// <param name="session">The session to operate on.</param>
 /// <param name="consumer">The consumer to receive with.</param>
 /// <returns>The Message received, or <code>null</code> if none</returns>
 protected virtual Message DoReceive(ISession session, IMessageConsumer consumer)
 {
     try
     {
         long timeout = ReceiveTimeout;
         EmsResourceHolder resourceHolder =
         (EmsResourceHolder)TransactionSynchronizationManager.GetResource(ConnectionFactory);
         if (resourceHolder != null && resourceHolder.HasTimeout)
         {
             timeout = Convert.ToInt64(resourceHolder.TimeToLiveInMilliseconds);
         }
         Message message = (timeout > 0)
                               ? consumer.Receive(timeout)
                               : consumer.Receive();
         if (session.Transacted)
         {
             // Commit necessary - but avoid commit call is Session transaction is externally coordinated.
             if (IsSessionLocallyTransacted(session))
             {
                 // Transacted session created by this template -> commit.
                 EmsUtils.CommitIfNecessary(session);
             }
         }
         else if (IsClientAcknowledge(session))
         {
             // Manually acknowledge message, if any.
             if (message != null)
             {
                 message.Acknowledge();
             }
         }
         return message;
     }
     finally
     {
         EmsUtils.CloseMessageConsumer(consumer);
     }
 }