MessageQueue.Receive MessageQueue.Receive MessageQueue.Receive MessageQueue.Receive Method

Definition

Empfängt die erste Meldung aus der Warteschlange und entfernt sie aus der Warteschlange.Receives the first message in the queue, removing it from the queue.

Überlädt

Receive() Receive() Receive() Receive()

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the queue referenced by the MessageQueue. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction)

Empfängt die erste verfügbare Meldung aus der transaktionalen Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the transactional queue referenced by the MessageQueue. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the queue referenced by the MessageQueue. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist, und wartet, bis eine Meldung in der Warteschlange verfügbar ist oder das Timeout abläuft.Receives the first message available in the queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange.Receives the current message in the queue, using a specified cursor. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction)

Empfängt die erste verfügbare Meldung aus der transaktionalen Warteschlange, auf die die MessageQueue verweist, und wartet, bis eine Meldung in der Warteschlange verfügbar ist oder das Timeout abläuft.Receives the first message available in the transactional queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the queue referenced by the MessageQueue. Dieser Aufruf ist synchron und wartet, bis entweder eine Meldung in der Warteschlange verfügbar ist oder der Timeout abläuft.This call is synchronous, and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange.Receives the current message in the queue, using a specified cursor. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange.Receives the current message in the queue, using a specified cursor. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive() Receive() Receive() Receive()

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the queue referenced by the MessageQueue. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.This call is synchronous, and blocks the current thread of execution until a message is available.

public:
 System::Messaging::Message ^ Receive();
public System.Messaging.Message Receive ();
member this.Receive : unit -> System.Messaging.Message
Public Function Receive () As Message

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.A Message that references the first message available in the queue.

Ausnahmen

Fehler beim Zugriff auf eine Message Queuing-Methode.An error occurred when accessing a Message Queuing method.

Beispiele

Im folgenden Codebeispiel wird eine Nachricht aus einer Warteschlange empfangen und Informationen über diese Nachricht an den Bildschirm ausgegeben.The following code example receives a message from a queue and outputs information about that message to the screen.

#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

Hinweise

Verwenden Sie diese Überladung, um eine Nachricht aus einer Warteschlange zu empfangen, oder warten Sie, bis Nachrichten in der Warteschlange vorliegen.Use this overload to receive a message from a queue, or wait until there are messages in the queue.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht, wodurch Sie aus der Warteschlange entfernt wird.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Bei nachfolgenden Receive Aufrufen von werden die Nachrichten in der Warteschlange oder neue Nachrichten mit höherer Priorität zurückgegeben.Subsequent calls to Receive will return the messages that follow in the queue, or new, higher priority messages.

Verwenden Sie die Peek -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne Sie aus der Warteschlange zu entfernen.To read the first message in a queue without removing it from the queue, use the Peek method. Die Peek Methode gibt immer die erste Nachricht in der Warteschlange zurück, sodass nachfolgende Aufrufe der Methode dieselbe Nachricht zurückgeben, es sei denn, eine Nachricht mit höherer Priorität wird in der Warteschlange eintreffen.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue.

Verwenden Sie einen- Receive Befehl, wenn es zulässig ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Da diese Überladung der Receive -Methode ein unendliches Timeout angibt, wartet die Anwendung möglicherweise unbegrenzt.Because this overload of the Receive method specifies an infinite time-out, the application might wait indefinitely. Wenn die Anwendungs Verarbeitung fortgesetzt werden soll, ohne auf die Meldung zu warten, sollten Sie die asynchrone-Methode BeginReceiveverwenden.If the application processing should continue without waiting for the message, consider using the asynchronous method, BeginReceive.

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppen Modi verfügbar ist.The following table shows whether this method is available in various Workgroup modes.

Arbeitsgruppen ModusWorkgroup mode VerfügbarAvailable
Lokaler ComputerLocal computer JaYes
Name des lokalen Computers und des direkten FormatsLocal computer and direct format name JaYes
Remote ComputerRemote computer NeinNo
Name des Remote Computers und des direkten FormatsRemote computer and direct format name JaYes
Siehe auch

Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction)

Empfängt die erste verfügbare Meldung aus der transaktionalen Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the transactional queue referenced by the MessageQueue. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.This call is synchronous, and blocks the current thread of execution until a message is available.

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

Parameter

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.A Message that references the first message available in the queue.

Ausnahmen

Fehler beim Zugriff auf eine Message Queuing-Methode.An error occurred when accessing a Message Queuing method.

- oder --or-

Die Warteschlange ist nicht transaktional.The queue is non-transactional.

Beispiele

Im folgenden Codebeispiel wird eine Verbindung mit einer Transaktions Warteschlange auf dem lokalen Computer hergestellt und eine Nachricht an die Warteschlange gesendet.The following code example connects to a transactional queue on the local computer and sends a message to the queue. Anschließend wird die Nachricht empfangen, die eine Bestellung enthält.It then receives the message that contains an order. Wenn eine nicht transaktionale Warteschlange festgestellt wird, löst Sie eine Ausnahme aus und führt einen Rollback für die Transaktion aus.If it encounters a non-transactional queue, it will throw and exception and rollback the transaction.

#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

Hinweise

Verwenden Sie diese Überladung, um eine Nachricht aus einer Transaktions Warteschlange zu empfangen, indem Sie den transaction vom-Parameter definierten internen Transaktionskontext verwenden, oder warten Sie, bis Nachrichten in der Warteschlange vorhanden sind.Use this overload to receive a message from a transactional queue using the internal transaction context defined by the transaction parameter, or wait until there are messages in the queue.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht, wodurch Sie aus der Warteschlange entfernt wird.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Bei nachfolgenden Receive Aufrufen von werden die Nachrichten in der Warteschlange zurückgegeben.Subsequent calls to Receive will return the messages that follow in the queue.

Da diese Methode für eine transaktionale Warteschlange aufgerufen wird, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird.Because this method is called on a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn ein Commit für die Transaktion ausgeführt wird.The message is not permanently removed from the queue until the transaction is committed.

Verwenden Sie die Peek -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne Sie aus der Warteschlange zu entfernen.To read the first message in a queue without removing it from the queue, use the Peek method. Die Peek Methode gibt immer die erste Nachricht in der Warteschlange zurück, sodass nachfolgende Aufrufe der Methode dieselbe Nachricht zurückgeben, es sei denn, eine Nachricht mit höherer Priorität wird in der Warteschlange eintreffen.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. Es ist kein Transaktionskontext mit einer Meldung verknüpft, die Peekvon einem-Befehl zurückgegeben wird.There is no transaction context associated with a message returned by a call to Peek. Da Peek keine Nachrichten in der Warteschlange entfernt, gibt es nichts, was durch einen- AbortRückruf zurückgesetzt werden kann.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Verwenden Sie einen- Receive Befehl, wenn es zulässig ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Da diese Überladung der Receive -Methode ein unendliches Timeout angibt, wartet die Anwendung möglicherweise unbegrenzt.Because this overload of the Receive method specifies an infinite time-out, the application might wait indefinitely. Wenn die Anwendungs Verarbeitung fortgesetzt werden soll, ohne auf die Meldung zu warten, sollten Sie die asynchrone-Methode BeginReceiveverwenden.If the application processing should continue without waiting for the message, consider using the asynchronous method, BeginReceive.

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppen Modi verfügbar ist.The following table shows whether this method is available in various Workgroup modes.

Arbeitsgruppen ModusWorkgroup mode VerfügbarAvailable
Lokaler ComputerLocal computer JaYes
Name des lokalen Computers und des direkten FormatsLocal computer and direct format name JaYes
Remote ComputerRemote computer NeinNo
Name des Remote Computers und des direkten FormatsRemote computer and direct format name JaYes
Siehe auch

Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the queue referenced by the MessageQueue. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.This call is synchronous, and blocks the current thread of execution until a message is available.

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

Parameter

transactionType
MessageQueueTransactionType MessageQueueTransactionType MessageQueueTransactionType MessageQueueTransactionType

Einer der MessageQueueTransactionType-Werte, der den Typ des Transaktionskontexts beschreibt, der der Meldung zugeordnet werden soll.One of the MessageQueueTransactionType values, describing the type of transaction context to associate with the message.

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.A Message that references the first message available in the queue.

Ausnahmen

Fehler beim Zugriff auf eine Message Queuing-Methode.An error occurred when accessing a Message Queuing method.

Der transactionType-Parameter ist keiner der MessageQueueTransactionType-Member.The transactionType parameter is not one of the MessageQueueTransactionType members.

Beispiele

Das folgende Codebeispiel veranschaulicht die Verwendung von Receive(MessageQueueTransactionType).The following code example demonstrates the use of 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); 

Hinweise

Verwenden Sie diese Überladung, um eine Nachricht aus einer Warteschlange mithilfe eines vom transactionType -Parameter definierten Transaktions Kontexts zu empfangen, oder warten Sie, bis Nachrichten in der Warteschlange vorhanden sind.Use this overload to receive a message from a queue using a transaction context defined by the transactionType parameter, or wait until there are messages in the queue.

Geben Automatic Sie für transactionType den-Parameter an, wenn bereits ein externer Transaktionskontext an den Thread angefügt ist, den Sie zum Empfangen der Nachricht verwenden möchten.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to receive the message. Geben Single Sie an, ob die Nachricht als einzelne interne Transaktion empfangen werden soll.Specify Single if you want to receive the message as a single internal transaction. Sie können angeben None , ob eine Nachricht von einer Transaktions Warteschlange außerhalb eines Transaktions Kontexts empfangen werden soll.You can specify None if you want to receive a message from a transactional queue outside of a transaction context.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht, wodurch Sie aus der Warteschlange entfernt wird.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Bei nachfolgenden Receive Aufrufen von werden die Nachrichten in der Warteschlange zurückgegeben.Subsequent calls to Receive will return the messages that follow in the queue.

Wenn diese Methode aufgerufen wird, um eine Nachricht aus einer Transaktions Warteschlange zu empfangen, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird.If this method is called to receive a message from a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn ein Commit für die Transaktion ausgeführt wird.The message is not permanently removed from the queue until the transaction is committed.

Verwenden Sie die Peek -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne Sie aus der Warteschlange zu entfernen.To read the first message in a queue without removing it from the queue, use the Peek method. Die Peek Methode gibt immer die erste Nachricht in der Warteschlange zurück, sodass nachfolgende Aufrufe der Methode dieselbe Nachricht zurückgeben, es sei denn, eine Nachricht mit höherer Priorität wird in der Warteschlange eintreffen.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. Es ist kein Transaktionskontext mit einer Meldung verknüpft, die Peekvon einem-Befehl zurückgegeben wird.There is no transaction context associated with a message returned by a call to Peek. Da Peek keine Nachrichten in der Warteschlange entfernt, gibt es nichts, was durch einen- AbortRückruf zurückgesetzt werden kann.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Verwenden Sie einen- Receive Befehl, wenn es zulässig ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Da diese Überladung der Receive -Methode ein unendliches Timeout angibt, wartet die Anwendung möglicherweise unbegrenzt.Because this overload of the Receive method specifies an infinite time-out, the application might wait indefinitely. Wenn die Anwendungs Verarbeitung fortgesetzt werden soll, ohne auf die Meldung zu warten, sollten Sie die asynchrone-Methode BeginReceiveverwenden.If the application processing should continue without waiting for the message, consider using the asynchronous method, BeginReceive.

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppen Modi verfügbar ist.The following table shows whether this method is available in various Workgroup modes.

Arbeitsgruppen ModusWorkgroup mode VerfügbarAvailable
Lokaler ComputerLocal computer JaYes
Name des lokalen Computers und des direkten FormatsLocal computer and direct format name JaYes
Remote ComputerRemote computer NeinNo
Name des Remote Computers und des direkten FormatsRemote computer and direct format name JaYes
Siehe auch

Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist, und wartet, bis eine Meldung in der Warteschlange verfügbar ist oder das Timeout abläuft.Receives the first message available in the queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

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

Parameter

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.A TimeSpan that indicates the time to wait until a new message is available for inspection.

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.A Message that references the first message available in the queue.

Ausnahmen

Der für den timeout-Parameter angegebene Wert ist ungültig. Möglicherweise ist der timeout kleiner als Zero oder größer als der InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.A message did not arrive in the queue before the time-out expired.

- oder --or-

Fehler beim Zugriff auf eine Message Queuing-Methode.An error occurred when accessing a Message Queuing method

Beispiele

Im folgenden Codebeispiel wird eine Nachricht aus einer Warteschlange empfangen und Informationen über diese Nachricht an den Bildschirm ausgegeben.The following code example receives a message from a queue and outputs information about that message to the screen. Im Beispiel wird die Ausführung von bis zu fünf Sekunden angehalten, während darauf gewartet wird, dass eine Nachricht in der Warteschlange eintrifft.The example pauses execution for up to five seconds while waiting for a message to arrive in the queue.

#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

Hinweise

Mit dieser Überladung können Sie eine Meldung empfangen und nach einer angegebenen Zeitspanne beenden, sofern sich keine Meldungen in der Warteschlange befinden.Use this overload to receive a message and return in a specified period of time if there are no messages in the queue.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht, wobei Sie aus der Warteschlange entfernt wird.The Receive method allows for the synchronous reading of a message, removing it from the queue. Bei nachfolgenden Receive Aufrufen von werden die Nachrichten in der Warteschlange oder neue Nachrichten mit höherer Priorität zurückgegeben.Subsequent calls to Receive will return the messages that follow in the queue, or new, higher priority messages.

Verwenden Sie die Peek -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne Sie aus der Warteschlange zu entfernen.To read the first message in a queue without removing it from the queue, use the Peek method. Die Peek Methode gibt immer die erste Nachricht in der Warteschlange zurück, sodass nachfolgende Aufrufe der Methode dieselbe Nachricht zurückgeben, es sei denn, eine Nachricht mit höherer Priorität wird in der Warteschlange eintreffen.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue.

Verwenden Sie einen- Receive Befehl, wenn es zulässig ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Der Thread wird für die angegebene Zeitspanne blockiert oder unbegrenzt, wenn Sie den Wert InfiniteTimeout für den timeout Parameter angegeben haben.The thread will be blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Wenn die Anwendungs Verarbeitung fortgesetzt werden soll, ohne auf eine Nachricht zu warten, sollten Sie die asynchrone-Methode BeginReceiveverwenden.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppen Modi verfügbar ist.The following table shows whether this method is available in various Workgroup modes.

Arbeitsgruppen ModusWorkgroup mode VerfügbarAvailable
Lokaler ComputerLocal computer JaYes
Name des lokalen Computers und des direkten FormatsLocal computer and direct format name JaYes
Remote ComputerRemote computer NeinNo
Name des Remote Computers und des direkten FormatsRemote computer and direct format name JaYes
Siehe auch

Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange.Receives the current message in the queue, using a specified cursor. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.If no message is available, this method waits until either a message is available, or the time-out expires.

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

Parameter

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.A TimeSpan that indicates the time to wait until a new message is available for inspection.

cursor
Cursor Cursor Cursor Cursor

Ein Cursor, der eine bestimmte Position in der Meldungswarteschlange beibehält.A Cursor that maintains a specific position in the message queue.

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.A Message that references the first message available in the queue.

Ausnahmen

Der für den timeout-Parameter angegebene Wert ist ungültig. Möglicherweise ist der timeout kleiner als Zero oder größer als der InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.A message did not arrive in the queue before the time-out expired.

- oder --or-

Fehler beim Zugriff auf eine Message Queuing-Methode.An error occurred when accessing a Message Queuing method

Mit dieser Überladung können Sie eine Meldung empfangen und nach einer angegebenen Zeitspanne beenden, sofern sich keine Meldungen in der Warteschlange befinden.Use this overload to receive a message and return in a specified period of time if there are no messages in the queue.

Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction)

Empfängt die erste verfügbare Meldung aus der transaktionalen Warteschlange, auf die die MessageQueue verweist, und wartet, bis eine Meldung in der Warteschlange verfügbar ist oder das Timeout abläuft.Receives the first message available in the transactional queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

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

Parameter

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.A TimeSpan that indicates the time to wait until a new message is available for inspection.

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.A Message that references the first message available in the queue.

Ausnahmen

Der für den timeout-Parameter angegebene Wert ist ungültig. Möglicherweise ist der timeout kleiner als Zero oder größer als der InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.A message did not arrive in the queue before the time-out expired.

- oder --or-

Die Warteschlange ist nicht transaktional.The queue is non-transactional.

- oder --or-

Fehler beim Zugriff auf eine Message Queuing-Methode.An error occurred when accessing a Message Queuing method.

Beispiele

Im folgenden Codebeispiel wird die Verwendung dieser Methode veranschaulicht.The following code example demonstrates the use of this method.

#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

Hinweise

Verwenden Sie diese Überladung, um eine Nachricht aus einer Transaktions Warteschlange mit dem vom transaction -Parameter definierten internen Transaktionskontext zu empfangen und innerhalb eines angegebenen Zeitraums zurückzugeben, wenn keine Nachrichten in der Warteschlange vorhanden sind.Use this overload to receive a message from a transactional queue using the internal transaction context defined by the transaction parameter, and return within a specified period of time if there are no messages in the queue.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht, wodurch Sie aus der Warteschlange entfernt wird.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Bei nachfolgenden Receive Aufrufen von werden die Nachrichten in der Warteschlange zurückgegeben.Subsequent calls to Receive will return the messages that follow in the queue.

Da diese Methode für eine transaktionale Warteschlange aufgerufen wird, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird.Because this method is called on a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn ein Commit für die Transaktion ausgeführt wird.The message is not permanently removed from the queue until the transaction is committed.

Verwenden Sie die Peek -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne Sie aus der Warteschlange zu entfernen.To read the first message in a queue without removing it from the queue, use the Peek method. Die Peek Methode gibt immer die erste Nachricht in der Warteschlange zurück, sodass nachfolgende Aufrufe der Methode dieselbe Nachricht zurückgeben, es sei denn, eine Nachricht mit höherer Priorität wird in der Warteschlange eintreffen.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. Es ist kein Transaktionskontext mit einer Meldung verknüpft, die Peekvon einem-Befehl zurückgegeben wird.There is no transaction context associated with a message returned by a call to Peek. Da Peek keine Nachrichten in der Warteschlange entfernt, gibt es nichts, was durch einen- AbortRückruf zurückgesetzt werden kann.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Verwenden Sie einen- Receive Befehl, wenn es zulässig ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Der Thread wird für die angegebene Zeitspanne blockiert oder unbegrenzt, wenn Sie den Wert InfiniteTimeout für den timeout Parameter angegeben haben.The thread will be blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Wenn die Anwendungs Verarbeitung fortgesetzt werden soll, ohne auf eine Nachricht zu warten, sollten Sie die asynchrone-Methode BeginReceiveverwenden.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppen Modi verfügbar ist.The following table shows whether this method is available in various Workgroup modes.

Arbeitsgruppen ModusWorkgroup mode VerfügbarAvailable
Lokaler ComputerLocal computer JaYes
Name des lokalen Computers und des direkten FormatsLocal computer and direct format name JaYes
Remote ComputerRemote computer NeinNo
Name des Remote Computers und des direkten FormatsRemote computer and direct format name JaYes
Siehe auch

Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the queue referenced by the MessageQueue. Dieser Aufruf ist synchron und wartet, bis entweder eine Meldung in der Warteschlange verfügbar ist oder der Timeout abläuft.This call is synchronous, and waits until either a message is available in the queue, or the time-out expires.

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

Parameter

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.A TimeSpan that indicates the time to wait until a new message is available for inspection.

transactionType
MessageQueueTransactionType MessageQueueTransactionType MessageQueueTransactionType MessageQueueTransactionType

Einer der MessageQueueTransactionType-Werte, der den Typ des Transaktionskontexts beschreibt, der der Meldung zugeordnet werden soll.One of the MessageQueueTransactionType values, describing the type of transaction context to associate with the message.

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.A Message that references the first message available in the queue.

Ausnahmen

Der für den timeout-Parameter angegebene Wert ist ungültig. Möglicherweise ist der timeout kleiner als Zero oder größer als der InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

Der transactionType-Parameter ist keiner der MessageQueueTransactionType-Member.The transactionType parameter is not one of the MessageQueueTransactionType members.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.A message did not arrive in the queue before the time-out expired.

- oder --or-

Fehler beim Zugriff auf eine Message Queuing-Methode.An error occurred when accessing a Message Queuing method.

Beispiele

Im folgenden Codebeispiel wird die Verwendung dieser Methode veranschaulicht.The following code example demonstrates the use of this method.


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

Hinweise

Verwenden Sie diese Überladung, um eine Nachricht aus einer Warteschlange zu empfangen, indem transactionType Sie einen vom-Parameter definierten Transaktionskontext verwenden und in einem angegebenen Zeitraum zurückgeben, wenn keine Nachrichten in der Warteschlange vorhanden sind.Use this overload to receive a message from a queue using a transaction context defined by the transactionType parameter, and return in a specified period of time if there are no messages in the queue.

Geben Automatic Sie für transactionType den-Parameter an, wenn bereits ein externer Transaktionskontext an den Thread angefügt ist, den Sie zum Empfangen der Nachricht verwenden möchten.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to receive the message. Geben Single Sie an, ob die Nachricht als einzelne interne Transaktion empfangen werden soll.Specify Single if you want to receive the message as a single internal transaction. Sie können angeben None , ob eine Nachricht von einer Transaktions Warteschlange außerhalb eines Transaktions Kontexts empfangen werden soll.You can specify None if you want to receive a message from a transactional queue outside of a transaction context.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht, wodurch Sie aus der Warteschlange entfernt wird.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Bei nachfolgenden Receive Aufrufen von werden die Nachrichten in der Warteschlange zurückgegeben.Subsequent calls to Receive will return the messages that follow in the queue.

Wenn diese Methode aufgerufen wird, um eine Nachricht aus einer Transaktions Warteschlange zu empfangen, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird.If this method is called to receive a message from a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn ein Commit für die Transaktion ausgeführt wird.The message is not permanently removed from the queue until the transaction is committed.

Verwenden Sie die Peek -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne Sie aus der Warteschlange zu entfernen.To read the first message in a queue without removing it from the queue, use the Peek method. Die Peek Methode gibt immer die erste Nachricht in der Warteschlange zurück, sodass nachfolgende Aufrufe der Methode dieselbe Nachricht zurückgeben, es sei denn, eine Nachricht mit höherer Priorität wird in der Warteschlange eintreffen.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. Es ist kein Transaktionskontext mit einer Meldung verknüpft, die Peekvon einem-Befehl zurückgegeben wird.There is no transaction context associated with a message returned by a call to Peek. Da Peek keine Nachrichten in der Warteschlange entfernt, gibt es nichts, was durch einen- AbortRückruf zurückgesetzt werden kann.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Verwenden Sie einen- Receive Befehl, wenn es zulässig ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Der Thread wird für die angegebene Zeitspanne blockiert oder unbegrenzt, wenn Sie den Wert InfiniteTimeout für den timeout Parameter angegeben haben.The thread will be blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Wenn die Anwendungs Verarbeitung fortgesetzt werden soll, ohne auf eine Nachricht zu warten, sollten Sie die asynchrone-Methode BeginReceiveverwenden.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppen Modi verfügbar ist.The following table shows whether this method is available in various Workgroup modes.

Arbeitsgruppen ModusWorkgroup mode VerfügbarAvailable
Lokaler ComputerLocal computer JaYes
Name des lokalen Computers und des direkten FormatsLocal computer and direct format name JaYes
Remote ComputerRemote computer NeinNo
Name des Remote Computers und des direkten FormatsRemote computer and direct format name JaYes
Siehe auch

Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange.Receives the current message in the queue, using a specified cursor. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.If no message is available, this method waits until either a message is available, or the time-out expires.

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

Parameter

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.A TimeSpan that indicates the time to wait until a new message is available for inspection.

cursor
Cursor Cursor Cursor Cursor

Ein Cursor, der eine bestimmte Position in der Meldungswarteschlange beibehält.A Cursor that maintains a specific position in the message queue.

Gibt zurück

Eine Message, die auf eine Meldung in der Warteschlange verweist.A Message that references a message in the queue.

Ausnahmen

Der cursor-Parameter ist null.The cursor parameter is null.

- oder --or- Der transaction-Parameter ist null.The transaction parameter is null.

Der für den timeout-Parameter angegebene Wert ist nicht gültig.The value specified for the timeout parameter is not valid. Möglicherweise ist timeout kleiner als Zero oder größer als InfiniteTimeout.Possibly timeout is less than Zero or greater than InfiniteTimeout.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.A message did not arrive in the queue before the time-out expired.

- oder --or-

Die Warteschlange ist nicht transaktional.The queue is non-transactional.

- oder --or-

Fehler beim Zugriff auf eine Message Queuing-Methode.An error occurred when accessing a Message Queuing method.

Hinweise

Verwenden Sie diese Überladung, um eine Nachricht aus einer Transaktions Warteschlange mit dem vom transaction -Parameter definierten internen Transaktionskontext zu empfangen und innerhalb eines angegebenen Zeitraums zurückzugeben, wenn keine Nachrichten in der Warteschlange vorhanden sind.Use this overload to receive a message from a transactional queue using the internal transaction context defined by the transaction parameter, and return within a specified period of time if there are no messages in the queue.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht, wodurch Sie aus der Warteschlange entfernt wird.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Nachfolgende Aufrufe Receive von geben die Nachrichten zurück, die in der Warteschlange befolgt werden.Subsequent calls to Receive return the messages that follow in the queue.

Da diese Methode für eine transaktionale Warteschlange aufgerufen wird, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird.Because this method is called on a transactional queue, the message that is received is returned to the queue if the transaction is aborted. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn ein Commit für die Transaktion ausgeführt wird.The message is not permanently removed from the queue until the transaction is committed.

Verwenden Sie die Peek -Methode, um eine Nachricht in einer Warteschlange zu lesen, ohne Sie aus der Warteschlange zu entfernen.To read a message in a queue without removing it from the queue, use the Peek method. Es ist kein Transaktionskontext mit einer Meldung verknüpft, die Peekvon einem-Befehl zurückgegeben wird.There is no transaction context associated with a message returned by a call to Peek. Da Peek keine Nachrichten in der Warteschlange entfernt, kann kein Rollback durch einen Abort-Befehl ausgeführt werden.Because Peek does not remove any messages in the queue, there is nothing to roll back by a call to Abort.

Verwenden Sie einen- Receive Befehl, wenn es zulässig ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Der Thread wird für die angegebene Zeitspanne blockiert oder unbegrenzt, wenn Sie den Wert InfiniteTimeout für den timeout Parameter angegeben haben.The thread is blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Wenn die Anwendungs Verarbeitung fortgesetzt werden soll, ohne auf eine Nachricht zu warten, sollten Sie die asynchrone-Methode BeginReceiveverwenden.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppen Modi verfügbar ist.The following table shows whether this method is available in various Workgroup modes.

Arbeitsgruppen ModusWorkgroup mode VerfügbarAvailable
Lokaler ComputerLocal computer JaYes
Name des lokalen Computers und des direkten FormatsLocal computer and direct format name JaYes
Remote ComputerRemote computer NeinNo
Name des Remote Computers und des direkten FormatsRemote computer and direct format name JaYes
Siehe auch

Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange.Receives the current message in the queue, using a specified cursor. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.If no message is available, this method waits until either a message is available, or the time-out expires.

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

Parameter

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.A TimeSpan that indicates the time to wait until a new message is available for inspection.

cursor
Cursor Cursor Cursor Cursor

Ein Cursor, der eine bestimmte Position in der Meldungswarteschlange beibehält.A Cursor that maintains a specific position in the message queue.

transactionType
MessageQueueTransactionType MessageQueueTransactionType MessageQueueTransactionType MessageQueueTransactionType

Einer der MessageQueueTransactionType-Werte, der den Typ des Transaktionskontexts beschreibt, der der Meldung zugeordnet werden soll.One of the MessageQueueTransactionType values that describes the type of transaction context to associate with the message.

Gibt zurück

Eine Message, die auf eine Meldung in der Warteschlange verweist.A Message that references a message in the queue.

Ausnahmen

Der cursor-Parameter ist null.The cursor parameter is null.

Der für den timeout-Parameter angegebene Wert ist nicht gültig.The value specified for the timeout parameter is not valid. Möglicherweise ist timeout kleiner als Zero oder größer als InfiniteTimeout.Possibly timeout is less than Zero or greater than InfiniteTimeout.

Der transactionType-Parameter ist keiner der MessageQueueTransactionType-Member.The transactionType parameter is not one of the MessageQueueTransactionType members.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.A message did not arrive in the queue before the time-out expired.

- oder --or-

Fehler beim Zugriff auf eine Message Queuing-Methode.An error occurred when accessing a Message Queuing method.

Hinweise

Verwenden Sie diese Überladung, um eine Nachricht aus einer Warteschlange zu empfangen, indem transactionType Sie einen vom-Parameter definierten Transaktionskontext verwenden und in einem angegebenen Zeitraum zurückgeben, wenn keine Nachrichten in der Warteschlange vorhanden sind.Use this overload to receive a message from a queue using a transaction context defined by the transactionType parameter, and return in a specified period of time if there are no messages in the queue.

Geben Automatic Sie für transactionType den-Parameter an, wenn bereits ein externer Transaktionskontext an den Thread angefügt ist, den Sie zum Empfangen der Nachricht verwenden möchten.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to receive the message. Geben Single Sie an, ob die Nachricht als einzelne interne Transaktion empfangen werden soll.Specify Single if you want to receive the message as a single internal transaction. Sie können angeben None , ob eine Nachricht von einer Transaktions Warteschlange außerhalb eines Transaktions Kontexts empfangen werden soll.You can specify None if you want to receive a message from a transactional queue outside of a transaction context.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht, wodurch Sie aus der Warteschlange entfernt wird.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Nachfolgende Aufrufe Receive von geben die Nachrichten zurück, die in der Warteschlange befolgt werden.Subsequent calls to Receive return the messages that follow in the queue.

Wenn diese Methode aufgerufen wird, um eine Nachricht aus einer Transaktions Warteschlange zu empfangen, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird.If this method is called to receive a message from a transactional queue, the message that is received is returned to the queue if the transaction is aborted. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn ein Commit für die Transaktion ausgeführt wird.The message is not permanently removed from the queue until the transaction is committed.

Verwenden Sie die Peek -Methode, um eine Nachricht in einer Warteschlange zu lesen, ohne Sie aus der Warteschlange zu entfernen.To read a message in a queue without removing it from the queue, use the Peek method. Es ist kein Transaktionskontext mit einer Meldung verknüpft, die Peekvon einem-Befehl zurückgegeben wird.There is no transaction context associated with a message returned by a call to Peek. Da Peek keine Nachrichten in der Warteschlange entfernt, kann kein Rollback durch einen Abort-Befehl ausgeführt werden.Because Peek does not remove any messages in the queue, there is nothing to roll back by a call to Abort.

Verwenden Sie einen- Receive Befehl, wenn es zulässig ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Der Thread wird für die angegebene Zeitspanne blockiert oder unbegrenzt, wenn Sie den Wert InfiniteTimeout für den timeout Parameter angegeben haben.The thread is blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Wenn die Anwendungs Verarbeitung fortgesetzt werden soll, ohne auf eine Nachricht zu warten, sollten Sie die asynchrone-Methode BeginReceiveverwenden.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

In der folgenden Tabelle wird gezeigt, ob diese Methode in verschiedenen Arbeitsgruppen Modi verfügbar ist.The following table shows whether this method is available in various Workgroup modes.

Arbeitsgruppen ModusWorkgroup mode VerfügbarAvailable
Lokaler ComputerLocal computer JaYes
Name des lokalen Computers und des direkten FormatsLocal computer and direct format name JaYes
Remote ComputerRemote computer NeinNo
Name des Remote Computers und des direkten FormatsRemote computer and direct format name JaYes
Siehe auch

Gilt für: