MessageQueue.Receive Метод

Ссылка

Определение

Пространство имен:: System.Messaging

Сборка:: System.Messaging.dll

Важно!

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

Получает первое сообщение в очереди, удаляя его из очереди.

Перегрузки

Receive()	Получает первое доступное в очереди сообщение, на которое ссылается объект MessageQueue. Этот вызов является синхронным и он блокирует текущий поток выполнения, пока сообщение не станет доступным.
Receive(MessageQueueTransaction)	Получает первое доступное в транзакционной очереди сообщение, на которое ссылается объект MessageQueue. Этот вызов является синхронным и он блокирует текущий поток выполнения, пока сообщение не станет доступным.
Receive(MessageQueueTransactionType)	Получает первое доступное в очереди сообщение, на которое ссылается объект MessageQueue. Этот вызов является синхронным и он блокирует текущий поток выполнения, пока сообщение не станет доступным.
Receive(TimeSpan)	Получает первое сообщение, доступное в очереди, на которую ссылается объект MessageQueue, и ожидает пока в очереди не появится сообщение или пока не истечет тайм-аут.
Receive(TimeSpan, Cursor)	Получает текущее сообщение в очереди, используя заданный курсор. Если доступных сообщений нет, этот метод ожидает, пока не станет доступным сообщение или пока не истечет тайм-аут.
Receive(TimeSpan, MessageQueueTransaction)	Получает первое сообщение, доступное в транзакционной очереди, на которую ссылается объект MessageQueue, и ожидает, пока в очереди не появится сообщение или пока не истечет тайм-аут.
Receive(TimeSpan, MessageQueueTransactionType)	Получает первое доступное в очереди сообщение, на которое ссылается объект MessageQueue. Данный вызов является синхронным, и он ожидает, пока в очереди не появится сообщение, или пока не истечет тайм-аут.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Получает текущее сообщение в очереди, используя заданный курсор. Если доступных сообщений нет, этот метод ожидает, пока не станет доступным сообщение или пока не истечет тайм-аут.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Получает текущее сообщение в очереди, используя заданный курсор. Если доступных сообщений нет, этот метод ожидает, пока не станет доступным сообщение или пока не истечет тайм-аут.

Receive()

Получает первое доступное в очереди сообщение, на которое ссылается объект MessageQueue. Этот вызов является синхронным и он блокирует текущий поток выполнения, пока сообщение не станет доступным.

public:
 System::Messaging::Message ^ Receive();

public System.Messaging.Message Receive ();

member this.Receive : unit -> System.Messaging.Message

Public Function Receive () As Message

Возвращаемое значение

Message

Объект Message, ссылающийся на первое доступное в очереди сообщение.

Исключения

MessageQueueException

При обращении к методу службы очереди сообщений возникла ошибка.

Примеры

В следующем примере кода показано, как получить сообщение из очереди и вывести сведения об этом сообщении на экран.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// sends to a queue and receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends an Order to a queue.
   //*************************************************
   void SendMessage()
   {
      // Create a new order and set values.
      Order^ sentOrder = gcnew Order;
      sentOrder->orderId = 3;
      sentOrder->orderTime = DateTime::Now;

      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Send the Order to the queue.
      myQueue->Send( sentOrder );
      return;
   }

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Order^ myOrder = static_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
//         
// This example sends and receives a message from
// a queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    // This class represents an object the following example
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Sends an Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            
            // Create a new order and set values.
            Order sentOrder = new Order();
            sentOrder.orderId = 3;
            sentOrder.orderTime = DateTime.Now;

            // Connect to a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Send the Order to the queue.
            myQueue.Send(sentOrder);

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                Message myMessage =	myQueue.Receive();
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging

    ' This class represents an object the following example 
    ' sends to a queue and receives from a queue.
    Public Class Order
        Public orderId As Integer
        Public orderTime As DateTime
    End Class


   
    Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        '		 
        ' This example sends and receives a message from
        ' a qeue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Send a message to a queue.
            myNewQueue.SendMessage()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub


        '
        ' Sends an Order to a queue.
        '

        Public Sub SendMessage()

            ' Create a new order and set values.
            Dim sentOrder As New Order()
            sentOrder.orderId = 3
            sentOrder.orderTime = DateTime.Now

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Send the Order to the queue.
            myQueue.Send(sentOrder)

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessage()

            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate the body contains an Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType(Order)})

            Try

                ' Receive and format the message. 
                Dim myMessage As Message = myQueue.Receive()
                Dim myOrder As Order = CType(myMessage.Body, Order)

                ' Display message information.
                Console.WriteLine(("Order ID: " + _
                    myOrder.orderId.ToString()))
                Console.WriteLine(("Sent: " + _
                    myOrder.orderTime.ToString()))

            Catch m As MessageQueueException
                ' Handle Message Queuing exceptions.

            Catch e As InvalidOperationException
                ' Handle invalid serialization format.
                Console.WriteLine(e.Message)


                ' Catch other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Метод Receive позволяет синхронно считывать сообщение, тем самым удаляя его из очереди. Последующие вызовы будут возвращать Receive сообщения, следующие в очереди, или новые сообщения с более высоким приоритетом.

Используйте вызов , Receive если текущий поток может быть заблокирован во время ожидания поступления сообщения в очередь. Так как эта перегрузка Receive метода задает бесконечное время ожидания, приложение может ждать неограниченное время. Если обработка приложения должна продолжаться без ожидания сообщения, рассмотрите возможность использования асинхронного метода BeginReceive.

В следующей таблице показано, доступен ли этот метод в различных режимах рабочей группы.

Режим рабочей группы	Доступно
Локальный компьютер	Да
Имя локального компьютера и прямого формата	Да
Удаленный компьютер	Нет
Имя удаленного компьютера и прямого формата	Да

См. также раздел

Применяется к

Receive(MessageQueueTransaction)

Получает первое доступное в транзакционной очереди сообщение, на которое ссылается объект MessageQueue. Этот вызов является синхронным и он блокирует текущий поток выполнения, пока сообщение не станет доступным.

public:
 System::Messaging::Message ^ Receive(System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive (System.Messaging.MessageQueueTransaction transaction);

member this.Receive : System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (transaction As MessageQueueTransaction) As Message

Параметры

transaction: MessageQueueTransaction

Объект MessageQueueTransaction.

Возвращаемое значение

Message

Объект Message, ссылающийся на первое доступное в очереди сообщение.

Исключения

MessageQueueException

При обращении к методу службы очереди сообщений возникла ошибка.

-или-

Очередь является нетранзакционной.

Примеры

В следующем примере кода выполняется подключение к транзакционной очереди на локальном компьютере и отправка сообщения в очередь. Затем он получает сообщение, содержащее заказ. При обнаружении нетранзакционной очереди будет выдано исключение и откат транзакции.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends a message to a queue.
   //*************************************************
   void SendMessageTransactional()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Send a message to the queue.
      if ( myQueue->Transactional == true )
      {
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;

         // Begin the transaction.
         myTransaction->Begin();

         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );

         // Commit the transaction.
         myTransaction->Commit();
      }

      return;
   }


   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessageTransactional()
   {
      // Connect to a transactional queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Set the formatter.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );

      // Create a transaction.
      MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
      try
      {
         // Begin the transaction.
         myTransaction->Begin();

         // Receive the message. 
         Message^ myMessage = myQueue->Receive( myTransaction );
         String^ myOrder = static_cast<String^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( myOrder );

         // Commit the transaction.
         myTransaction->Commit();
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle nontransactional queues.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::TransactionUsage )
         {
            Console::WriteLine( "Queue is not transactional." );
         }

         // Else catch other sources of a MessageQueueException.
         // Roll back the transaction.
         myTransaction->Abort();
      }

      // Catch other exceptions as necessary, such as 
      // InvalidOperationException, thrown when the formatter 
      // cannot deserialize the message.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
// 
// This example sends and receives a message from
// a transactional queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessageTransactional();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessageTransactional();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //
        // This example sends and receives a message from
        // a transactional queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessageTransactional();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional();

            return;
        }

        //**************************************************
        // Sends a message to a queue.
        //**************************************************
        
        public void SendMessageTransactional()
        {
                        
            // Connect to a queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Send a message to the queue.
            if (myQueue.Transactional == true)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessageTransactional()
        {
            // Connect to a transactional queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Set the formatter.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});
            
            // Create a transaction.
            MessageQueueTransaction myTransaction = new
                MessageQueueTransaction();

            try
            {
                // Begin the transaction.
                myTransaction.Begin();
                
                // Receive the message.
                Message myMessage =	myQueue.Receive(myTransaction);
                String myOrder = (String)myMessage.Body;

                // Display message information.
                Console.WriteLine(myOrder);

                // Commit the transaction.
                myTransaction.Commit();
            }
            
            catch (MessageQueueException e)
            {
                // Handle nontransactional queues.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.TransactionUsage)
                {
                    Console.WriteLine("Queue is not transactional.");
                }
                
                // Else catch other sources of a MessageQueueException.

                // Roll back the transaction.
                myTransaction.Abort();
            }

            // Catch other exceptions as necessary, such as
            // InvalidOperationException, thrown when the formatter
            // cannot deserialize the message.

            return;
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        ' 
        ' This example sends and receives a message from
        ' a transactional queue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue

            ' Send a message to a queue.
            myNewQueue.SendMessageTransactional()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional()

            Return

        End Sub


        '
        ' Sends a message to a queue.
        '

        Public Sub SendMessageTransactional()

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Send a message to the queue.
            If myQueue.Transactional = True Then

                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()

            End If

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessageTransactional()

            ' Connect to a transactional queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Set the formatter.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Create a transaction.
            Dim myTransaction As New MessageQueueTransaction

            Try

                ' Begin the transaction.
                myTransaction.Begin()

                ' Receive the message. 
                Dim myMessage As Message = _
                    myQueue.Receive(myTransaction)
                Dim myOrder As [String] = CType(myMessage.Body, _
                    [String])

                ' Display message information.
                Console.WriteLine(myOrder)

                ' Commit the transaction.
                myTransaction.Commit()


            Catch e As MessageQueueException

                ' Handle nontransactional queues.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.TransactionUsage Then

                    Console.WriteLine("Queue is not transactional.")

                End If

                ' Else catch other sources of a MessageQueueException.


                ' Roll back the transaction.
                myTransaction.Abort()


                ' Catch other exceptions as necessary, such as 
                ' InvalidOperationException, thrown when the formatter
                ' cannot deserialize the message.

            End Try

            Return

        End Sub

End Class

Используйте эту перегрузку для получения сообщения из очереди транзакций с использованием внутреннего контекста транзакции, определенного transaction параметром , или дождитесь появления сообщений в очереди.

Метод Receive позволяет синхронно считывать сообщение, тем самым удаляя его из очереди. Последующие вызовы будут возвращать Receive сообщения, следующие в очереди.

Так как этот метод вызывается в очереди транзакций, полученное сообщение будет возвращено в очередь, если транзакция будет прервана. Сообщение не удаляется окончательно из очереди, пока транзакция не будет зафиксирована.

Чтобы прочитать первое сообщение в очереди, не удаляя его из очереди, используйте Peek метод . Метод Peek всегда возвращает первое сообщение в очереди, поэтому последующие вызовы метода возвращают одно и то же сообщение, если в очередь не поступает сообщение с более высоким приоритетом. Нет контекста транзакции, связанного с сообщением, возвращаемым вызовом Peekметода . Так как Peek не удаляет сообщения в очереди, откат не выполняется путем вызова Abortметода .

В следующей таблице показано, доступен ли этот метод в различных режимах рабочей группы.

Режим рабочей группы	Доступно
Локальный компьютер	Да
Имя локального компьютера и прямого формата	Да
Удаленный компьютер	Нет
Имя удаленного компьютера и прямого формата	Да

См. также раздел

Применяется к

Receive(MessageQueueTransactionType)

public:
 System::Messaging::Message ^ Receive(System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive (System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (transactionType As MessageQueueTransactionType) As Message

Параметры

transactionType: MessageQueueTransactionType

Одно из значений MessageQueueTransactionType, описывающее тип контекста транзакции, связываемого с сообщением.

Возвращаемое значение

Message

Объект Message, ссылающийся на первое доступное в очереди сообщение.

Исключения

MessageQueueException

При обращении к методу службы очереди сообщений возникла ошибка.

InvalidEnumArgumentException

Параметр transactionType не является одним из членов MessageQueueTransactionType.

Примеры

В следующем коде показано использование функции Receive(MessageQueueTransactionType).


// Connect to a transactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, MessageQueueTransactionType::Single);

// Simulate doing other work so the message has time to arrive.
System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));

// Set the formatter to indicate the message body contains a String.
queue->Formatter = gcnew XmlMessageFormatter(
    gcnew array<Type^>{String::typeid});

// Receive the message from the queue.  Because the Id of the message
// , it might not be the message just sent.
msg = queue->Receive(MessageQueueTransactionType::Single);

queue->Close();


// Connect to a transactional queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, MessageQueueTransactionType.Single);

// Simulate doing other work so the message has time to arrive.
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

// Set the formatter to indicate the message body contains a String.
queue.Formatter = new XmlMessageFormatter(new Type[]
    {typeof(String)});

// Receive the message from the queue.  Because the Id of the message
// , it might not be the message just sent.
msg = queue.Receive(MessageQueueTransactionType.Single);

Используйте эту перегрузку для получения сообщения из очереди с помощью контекста транзакции, определенного transactionType параметром , или дождитесь появления сообщений в очереди.

Укажите Automatic для transactionType параметра , если к потоку, который вы хотите использовать для получения сообщения, уже подключен внешний контекст транзакции. Укажите Single , нужно ли получать сообщение как одну внутреннюю транзакцию. Вы можете указать None , нужно ли получать сообщение из очереди транзакций за пределами контекста транзакции.

Метод Receive обеспечивает синхронное чтение сообщения, тем самым удаляя его из очереди. Последующие вызовы будут возвращать Receive сообщения, следующие в очереди.

Если этот метод вызывается для получения сообщения из очереди транзакций, полученное сообщение будет возвращено в очередь, если транзакция прервана. Сообщение не будет окончательно удалено из очереди, пока транзакция не будет зафиксирована.

Чтобы прочитать первое сообщение в очереди, не удаляя его из очереди, используйте Peek метод . Метод Peek всегда возвращает первое сообщение в очереди, поэтому последующие вызовы метода возвращают одно и то же сообщение, если в очередь не поступает сообщение с более высоким приоритетом. Контекст транзакции не связан с сообщением, возвращенным вызовом Peek. Так как Peek не удаляет сообщения из очереди, отката при вызове Abortне будет.

Используйте вызов , Receive если текущий поток может быть заблокирован, пока он ожидает поступления сообщения в очередь. Так как эта перегрузка Receive метода задает бесконечное время ожидания, приложение может ждать неограниченное время. Если обработка приложения должна продолжаться, не дожидаясь сообщения, рассмотрите возможность использования асинхронного метода BeginReceive.

В следующей таблице показано, доступен ли этот метод в различных режимах рабочей группы.

Режим рабочей группы	Доступно
Локальный компьютер	Да
Имя локального компьютера и прямого формата	Да
Удаленный компьютер	Нет
Имя удаленного компьютера и прямого формата	Да

См. также раздел

Применяется к

Receive(TimeSpan)

Получает первое сообщение, доступное в очереди, на которую ссылается объект MessageQueue, и ожидает пока в очереди не появится сообщение или пока не истечет тайм-аут.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout);

public System.Messaging.Message Receive (TimeSpan timeout);

member this.Receive : TimeSpan -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan) As Message

Параметры

timeout: TimeSpan

Структура TimeSpan, показывающая время ожидания нового сообщения для проверки.

Возвращаемое значение

Message

Объект Message, ссылающийся на первое доступное в очереди сообщение.

Исключения

ArgumentException

Для параметра timeout задано недопустимое значение; возможно, значение параметра timeout меньше Zero или больше InfiniteTimeout.

MessageQueueException

До истечения тайм-аута в очередь сообщений не поступало.

-или-

При обращении к методу службы очереди сообщений возникла ошибка.

Примеры

Следующий пример кода получает сообщение из очереди и выводит сведения об этом сообщении на экран. В этом примере выполнение приостанавливается на пять секунд, ожидая поступления сообщения в очередь.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         // Wait 5 seconds for a message to arrive.
         Message^ myMessage = myQueue->Receive( TimeSpan(0,0,5) );
         Order^ myOrder = static_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle no message arriving in the queue.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( "No message arrived in queue." );
         }

         // Handle other sources of a MessageQueueException.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
//         
// This example receives a message from a queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{
    // This class represents an object the following example
    // receives from a queue.

    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example receives a message from a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************

        public void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                // Wait 5 seconds for a message to arrive.
                Message myMessage =	myQueue.Receive(new
                    TimeSpan(0,0,5));
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }

            catch (MessageQueueException e)
            {
                // Handle no message arriving in the queue.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine("No message arrived in queue.");
                }			

                // Handle other sources of a MessageQueueException.
            }
            
            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging

' This class represents an object the following example 
' receives from a queue.
Public Class Order
        Public orderId As Integer
        Public orderTime As DateTime
End Class


   
Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        '		 
        ' This example receives a message from a queue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessage()

            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate body contains an Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType(Order)})

            Try

                ' Receive and format the message. 
                ' Wait 5 seconds for a message to arrive.
                Dim myMessage As Message = myQueue.Receive(New _
                    TimeSpan(0, 0, 5))
                Dim myOrder As Order = CType(myMessage.Body, Order)

                ' Display message information.
                Console.WriteLine(("Order ID: " + _
                    myOrder.orderId.ToString()))
                Console.WriteLine(("Sent: " + _
                    myOrder.orderTime.ToString()))

            Catch e As MessageQueueException
                ' Handle no message arriving in the queue.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.IOTimeout Then

                    Console.WriteLine("No message arrived in queue.")

                End If

                ' Handle other sources of a MessageQueueException.

            Catch e As InvalidOperationException
                ' Handle invalid serialization format.
                Console.WriteLine(e.Message)

                ' Catch other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Метод Receive позволяет синхронно считывать сообщение, удаляя его из очереди. Последующие вызовы будут возвращать Receive сообщения, следующие в очереди, или новые сообщения с более высоким приоритетом.

Используйте вызов , Receive если текущий поток может быть заблокирован, пока он ожидает поступления сообщения в очередь. Поток будет заблокирован в течение заданного периода времени или на неопределенный срок, если вы указали timeout значение InfiniteTimeout параметра. Если обработка приложения должна продолжаться без ожидания сообщения, рассмотрите возможность использования асинхронного метода BeginReceive.

В следующей таблице показано, доступен ли этот метод в различных режимах рабочей группы.

Режим рабочей группы	Доступно
Локальный компьютер	Да
Имя локального компьютера и прямого формата	Да
Удаленный компьютер	Нет
Имя удаленного компьютера и прямого формата	Да

См. также раздел

Применяется к

Receive(TimeSpan, Cursor)

Получает текущее сообщение в очереди, используя заданный курсор. Если доступных сообщений нет, этот метод ожидает, пока не станет доступным сообщение или пока не истечет тайм-аут.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor);

member this.Receive : TimeSpan * System.Messaging.Cursor -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor) As Message

Параметры

timeout: TimeSpan

Структура TimeSpan, показывающая время ожидания нового сообщения для проверки.

cursor: Cursor

Объект Cursor, который сохраняет определенное положение в очереди сообщений.

Возвращаемое значение

Message

Объект Message, ссылающийся на первое доступное в очереди сообщение.

Исключения

ArgumentException

MessageQueueException

До истечения тайм-аута в очередь сообщений не поступало.

-или-

При обращении к методу службы очереди сообщений возникла ошибка.

Применяется к

Receive(TimeSpan, MessageQueueTransaction)

Получает первое сообщение, доступное в транзакционной очереди, на которую ссылается объект MessageQueue, и ожидает, пока в очереди не появится сообщение или пока не истечет тайм-аут.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.MessageQueueTransaction transaction);

member this.Receive : TimeSpan * System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, transaction As MessageQueueTransaction) As Message

Параметры

timeout: TimeSpan

Структура TimeSpan, показывающая время ожидания нового сообщения для проверки.

transaction: MessageQueueTransaction

Объект MessageQueueTransaction.

Возвращаемое значение

Message

Объект Message, ссылающийся на первое доступное в очереди сообщение.

Исключения

ArgumentException

MessageQueueException

До истечения тайм-аута в очередь сообщений не поступало.

-или-

Очередь является нетранзакционной.

-или-

При обращении к методу службы очереди сообщений возникла ошибка.

Примеры

В следующем примере кода показано использование этого метода.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends a message to a transactional queue.
   //*************************************************
   void SendMessageTransactional()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Send a message to the queue.
      if ( myQueue->Transactional == true )
      {
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;

         // Begin the transaction.
         myTransaction->Begin();

         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );

         // Commit the transaction.
         myTransaction->Commit();
      }

      return;
   }

   //*************************************************
   // Receives a message from the transactional queue.
   //*************************************************
   void ReceiveMessageTransactional()
   {
      // Connect to a transactional queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Set the formatter.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );

      // Create a transaction.
      MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
      try
      {
         // Begin the transaction.
         myTransaction->Begin();

         // Receive the message. 
         // Wait five seconds for a message to arrive. 
         Message^ myMessage = myQueue->Receive( TimeSpan(0,0,5), myTransaction );
         String^ myOrder = static_cast<String^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( myOrder );

         // Commit the transaction.
         myTransaction->Commit();
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle nontransactional queues.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::TransactionUsage )
         {
            Console::WriteLine( "Queue is not transactional." );
         }
         // Handle no message arriving in the queue.
         else

         // Handle no message arriving in the queue.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( "No message in queue." );
         }

         // Else catch other sources of MessageQueueException.
         // Roll back the transaction.
         myTransaction->Abort();
      }

      // Catch other exceptions as necessary, such as 
      // InvalidOperationException, thrown when the formatter 
      // cannot deserialize the message.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
// 
// This example sends and receives a message from
// a transactional queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessageTransactional();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessageTransactional();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //
        // This example sends and receives a message from
        // a transactional queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessageTransactional();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional();

            return;
        }

        //**************************************************
        // Sends a message to a transactional queue.
        //**************************************************
        
        public void SendMessageTransactional()
        {
                        
            // Connect to a queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Send a message to the queue.
            if (myQueue.Transactional == true)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }

            return;
        }

        //**************************************************
        // Receives a message from the transactional queue.
        //**************************************************
        
        public  void ReceiveMessageTransactional()
        {
            // Connect to a transactional queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Set the formatter.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});
            
            // Create a transaction.
            MessageQueueTransaction myTransaction = new
                MessageQueueTransaction();

            try
            {
                // Begin the transaction.
                myTransaction.Begin();
                
                // Receive the message.
                // Wait five seconds for a message to arrive.
                Message myMessage =	myQueue.Receive(new
                    TimeSpan(0,0,5), myTransaction);
                
                String myOrder = (String)myMessage.Body;

                // Display message information.
                Console.WriteLine(myOrder);

                // Commit the transaction.
                myTransaction.Commit();
            }
            
            catch (MessageQueueException e)
            {
                // Handle nontransactional queues.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.TransactionUsage)
                {
                    Console.WriteLine("Queue is not transactional.");
                }

                    // Handle no message arriving in the queue.
                else if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine("No message in queue.");
                }
                
                // Else catch other sources of MessageQueueException.

                // Roll back the transaction.
                myTransaction.Abort();
            }

            // Catch other exceptions as necessary, such as
            // InvalidOperationException, thrown when the formatter
            // cannot deserialize the message.

            return;
        }
    }
}

Imports System.Messaging

Namespace MyProj


   
    Public Class MyNewQueue


        '**************************************************
        ' Provides an entry point into the application.
        ' 
        ' This example sends and receives a message from
        ' a transactional queue.
        '**************************************************

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue

            ' Send a message to a queue.
            myNewQueue.SendMessageTransactional()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional()

            Return

        End Sub


        '**************************************************
        ' Sends a message to a transactional queue.
        '**************************************************

        Public Sub SendMessageTransactional()

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Send a message to the queue.
            If myQueue.Transactional = True Then

                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()

            End If

            Return

        End Sub


        '**************************************************
        ' Receives a message from the transactional queue.
        '**************************************************

        Public Sub ReceiveMessageTransactional()

            ' Connect to a transactional queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Set the formatter.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Create a transaction.
            Dim myTransaction As New MessageQueueTransaction

            Try

                ' Begin the transaction.
                myTransaction.Begin()

                ' Receive the message. 
                ' Wait five seconds for a message to arrive. 
                Dim myMessage As Message = myQueue.Receive(New _
                    TimeSpan(0, 0, 5), myTransaction)
                Dim myOrder As [String] = CType(myMessage.Body, _
                    [String])

                ' Display message information.
                Console.WriteLine(myOrder)

                ' Commit the transaction.
                myTransaction.Commit()


            Catch e As MessageQueueException

                ' Handle nontransactional queues.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.TransactionUsage Then

                    Console.WriteLine("Queue is not transactional.")

                Else
                    ' Handle no message arriving in the queue.
                    If e.MessageQueueErrorCode = _
                        MessageQueueErrorCode.IOTimeout Then

                        Console.WriteLine("No message in queue.")

                    End If
                End If

                ' Else catch other sources of a MessageQueueException.

                ' Roll back the transaction.
                myTransaction.Abort()


                ' Catch other exceptions as necessary, such as InvalidOperationException,
                ' thrown when the formatter cannot deserialize the message.

            End Try

            Return

        End Sub

    End Class
End Namespace 'MyProj

Используйте эту перегрузку для получения сообщения из очереди транзакций с использованием внутреннего контекста транзакции, определенного transaction параметром , и возврата в течение указанного периода времени, если в очереди нет сообщений.

Так как этот метод вызывается в очереди транзакций, полученное сообщение будет возвращено в очередь, если транзакция прервана. Сообщение не будет окончательно удалено из очереди, пока транзакция не будет зафиксирована.

Чтобы прочитать первое сообщение в очереди, не удаляя его из очереди, используйте Peek метод . Метод Peek всегда возвращает первое сообщение в очереди, поэтому последующие вызовы метода возвращают одно и то же сообщение, если в очередь не поступает сообщение с более высоким приоритетом. Контекст транзакции не связан с сообщением, возвращенным вызовом Peek. Так как Peek не удаляет сообщения из очереди, отката при вызове Abortне будет.

В следующей таблице показано, доступен ли этот метод в различных режимах рабочей группы.

Режим рабочей группы	Доступно
Локальный компьютер	Да
Имя локального компьютера и прямого формата	Да
Удаленный компьютер	Нет
Имя удаленного компьютера и прямого формата	Да

См. также раздел

Применяется к

Receive(TimeSpan, MessageQueueTransactionType)

Получает первое доступное в очереди сообщение, на которое ссылается объект MessageQueue. Данный вызов является синхронным, и он ожидает, пока в очереди не появится сообщение, или пока не истечет тайм-аут.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : TimeSpan * System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, transactionType As MessageQueueTransactionType) As Message

Параметры

timeout: TimeSpan

Структура TimeSpan, показывающая время ожидания нового сообщения для проверки.

transactionType: MessageQueueTransactionType

Одно из значений MessageQueueTransactionType, описывающее тип контекста транзакции, связываемого с сообщением.

Возвращаемое значение

Message

Объект Message, ссылающийся на первое доступное в очереди сообщение.

Исключения

ArgumentException

InvalidEnumArgumentException

Параметр transactionType не является одним из членов MessageQueueTransactionType.

MessageQueueException

До истечения тайм-аута в очередь сообщений не поступало.

-или-

При обращении к методу службы очереди сообщений возникла ошибка.

Примеры

В следующем примере кода показано использование этого метода.


// Connect to a transactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, MessageQueueTransactionType::Single);

// Set the formatter to indicate the message body contains a String.
queue->Formatter = gcnew XmlMessageFormatter(
    gcnew array<Type^>{String::typeid});

// Receive the message from the queue. Because the Id of the message
// is not specified, it might not be the message just sent.
msg = queue->Receive(TimeSpan::FromSeconds(10.0),
    MessageQueueTransactionType::Single);

queue->Close();


// Connect to a transactional queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleTransQueue");

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, MessageQueueTransactionType.Single);

// Set the formatter to indicate the message body contains a String.
queue.Formatter = new XmlMessageFormatter(new Type[]
    {typeof(String)});

// Receive the message from the queue. Because the Id of the message
// is not specified, it might not be the message just sent.
msg = queue.Receive(TimeSpan.FromSeconds(10.0),
    MessageQueueTransactionType.Single);

Используйте эту перегрузку для получения сообщения из очереди с помощью контекста транзакции, определенного transactionType параметром , и возврата в течение указанного периода времени, если в очереди нет сообщений.

Если этот метод вызывается для получения сообщения из очереди транзакций, полученное сообщение будет возвращено в очередь, если транзакция будет прервана. Сообщение не удаляется окончательно из очереди, пока транзакция не будет зафиксирована.

Используйте вызов , Receive если текущий поток может быть заблокирован во время ожидания поступления сообщения в очередь. Поток будет заблокирован в течение заданного периода времени или на неопределенный срок, если вы указали timeout значение InfiniteTimeout параметра. Если обработка приложения должна продолжаться без ожидания сообщения, рассмотрите возможность использования асинхронного метода BeginReceive.

В следующей таблице показано, доступен ли этот метод в различных режимах рабочей группы.

Режим рабочей группы	Доступно
Локальный компьютер	Да
Имя локального компьютера и прямого формата	Да
Удаленный компьютер	Нет
Имя удаленного компьютера и прямого формата	Да

См. также раздел

Применяется к

Receive(TimeSpan, Cursor, MessageQueueTransaction)

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.MessageQueueTransaction transaction);

member this.Receive : TimeSpan * System.Messaging.Cursor * System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor, transaction As MessageQueueTransaction) As Message

Параметры

timeout: TimeSpan

Структура TimeSpan, показывающая время ожидания нового сообщения для проверки.

cursor: Cursor

Объект Cursor, который сохраняет определенное положение в очереди сообщений.

transaction: MessageQueueTransaction

Объект MessageQueueTransaction.

Возвращаемое значение

Message

Объект Message, ссылающийся на сообщение в очереди.

Исключения

ArgumentNullException

Параметр cursor имеет значение null.

-или-

Параметр transaction имеет значение null.

ArgumentException

Значение, заданное для параметра timeout, недопустимо. Возможно, значение параметра timeout меньше, чем Zero, или больше, чем InfiniteTimeout.

MessageQueueException

До истечения тайм-аута в очередь сообщений не поступало.

-или-

Очередь является нетранзакционной.

-или-

При обращении к методу службы очереди сообщений возникла ошибка.

Так как этот метод вызывается в очереди транзакций, полученное сообщение возвращается в очередь, если транзакция прервана. Сообщение не удаляется окончательно из очереди, пока транзакция не будет зафиксирована.

Чтобы прочитать сообщение в очереди, не удаляя его из очереди, используйте Peek метод . Нет контекста транзакции, связанного с сообщением, возвращаемым вызовом Peekметода . Так как Peek не удаляет сообщения в очереди, нет отката путем вызова Abortметода .

Используйте вызов , Receive если текущий поток может быть заблокирован во время ожидания поступления сообщения в очередь. Поток блокируется на определенный период времени или на неопределенный срок, если вы указали timeout значение InfiniteTimeout параметра. Если обработка приложения должна продолжаться без ожидания сообщения, рассмотрите возможность использования асинхронного метода BeginReceive.

В следующей таблице показано, доступен ли этот метод в различных режимах рабочей группы.

Режим рабочей группы	Доступно
Локальный компьютер	Да
Имя локального компьютера и прямого формата	Да
Удаленный компьютер	Нет
Имя удаленного компьютера и прямого формата	Да

См. также раздел

Применяется к

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : TimeSpan * System.Messaging.Cursor * System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor, transactionType As MessageQueueTransactionType) As Message

Параметры

timeout: TimeSpan

Структура TimeSpan, показывающая время ожидания нового сообщения для проверки.

cursor: Cursor

Объект Cursor, который сохраняет определенное положение в очереди сообщений.

transactionType: MessageQueueTransactionType

Одно из значений MessageQueueTransactionType, описывающее тип контекста транзакции, связываемого с сообщением.

Возвращаемое значение

Message

Объект Message, ссылающийся на сообщение в очереди.

Исключения

ArgumentNullException

Параметр cursor имеет значение null.

ArgumentException

InvalidEnumArgumentException

Параметр transactionType не является одним из членов MessageQueueTransactionType.

MessageQueueException

До истечения тайм-аута в очередь сообщений не поступало.

-или-

При обращении к методу службы очереди сообщений возникла ошибка.

Если этот метод вызывается для получения сообщения из очереди транзакций, полученное сообщение возвращается в очередь в случае прерывания транзакции. Сообщение не удаляется окончательно из очереди, пока транзакция не будет зафиксирована.

В следующей таблице показано, доступен ли этот метод в различных режимах рабочей группы.

Режим рабочей группы	Доступно
Локальный компьютер	Да
Имя локального компьютера и прямого формата	Да
Удаленный компьютер	Нет
Имя удаленного компьютера и прямого формата	Да

См. также раздел

Применяется к

Потокобезопасность

Метод не является потокобезопасном.

Поделиться через

MessageQueue.Receive Метод

Определение

Перегрузки

Receive()

Возвращаемое значение

Исключения

Примеры

Комментарии

См. также раздел

Применяется к

Receive(MessageQueueTransaction)

Параметры

Возвращаемое значение

Исключения

Примеры

Комментарии

См. также раздел

Применяется к

Receive(MessageQueueTransactionType)

Параметры

Возвращаемое значение

Исключения

Примеры

Комментарии

См. также раздел

Применяется к

Receive(TimeSpan)

Параметры

Возвращаемое значение

Исключения

Примеры

Комментарии

См. также раздел

Применяется к

Receive(TimeSpan, Cursor)

Параметры

Возвращаемое значение

Исключения

Применяется к

Receive(TimeSpan, MessageQueueTransaction)

Параметры

Возвращаемое значение

Исключения

Примеры

Комментарии

См. также раздел

Применяется к

Receive(TimeSpan, MessageQueueTransactionType)

Параметры

Возвращаемое значение

Исключения

Примеры

Комментарии

См. также раздел

Применяется к

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Параметры

Возвращаемое значение

Исключения

Комментарии

См. также раздел

Применяется к

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Параметры

Возвращаемое значение

Исключения

Комментарии

См. также раздел

Применяется к

Потокобезопасность

Дополнительные ресурсы