Freigeben über


MessageQueue.Receive Methode

Definition

Empfängt die erste Meldung aus der Warteschlange und entfernt sie aus der Warteschlange.

Überlädt

Receive()

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.

Receive(MessageQueueTransaction)

Empfängt die erste verfügbare Meldung aus der transaktionalen Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.

Receive(MessageQueueTransactionType)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.

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.

Receive(TimeSpan, Cursor)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.

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.

Receive(TimeSpan, MessageQueueTransactionType)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und wartet, bis entweder eine Meldung in der Warteschlange verfügbar ist oder der Timeout abläuft.

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.

Receive()

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.

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.

Ausnahmen

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Das folgende Codebeispiel empfängt eine Nachricht aus einer Warteschlange und gibt Informationen zu dieser Nachricht auf dem Bildschirm aus.

#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 vorhanden sind.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht, wodurch sie aus der Warteschlange entfernt wird. Nachfolgende Aufrufe von Receive geben die Nachrichten zurück, die in der Warteschlange folgen, oder neue Nachrichten mit höherer Priorität.

Verwenden Sie Peek die -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne sie aus der Warteschlange zu entfernen. 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.

Verwenden Sie einen Aufruf von Receive , wenn es akzeptabel ist, dass der aktuelle Thread blockiert wird, während er wartet, bis eine Nachricht in der Warteschlange eingeht. Da diese Überladung der Receive Methode ein unendliches Timeout angibt, wartet die Anwendung möglicherweise unbegrenzt. Wenn die Anwendungsverarbeitung fortgesetzt werden soll, ohne auf die Nachricht zu warten, sollten Sie die asynchrone Methode verwenden BeginReceive.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und des direkten Formats Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

Receive(MessageQueueTransaction)

Empfängt die erste verfügbare Meldung aus der transaktionalen Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.

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.

Ausnahmen

Fehler beim Zugriff auf eine Message Queuing-Methode.

- oder -

Die Warteschlange ist nicht transaktional.

Beispiele

Im folgenden Codebeispiel wird eine Verbindung mit einer Transaktionswarteschlange auf dem lokalen Computer hergestellt und eine Nachricht an die Warteschlange gesendet. Anschließend wird die Nachricht empfangen, die eine Bestellung enthält. Wenn eine nicht transaktionale Warteschlange auftritt, wird die Transaktion ausgelöst, ausnahmet und rollbackt.

#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 mithilfe des durch den transaction Parameter definierten internen Transaktionskontexts eine Nachricht von einer Transaktionswarteschlange zu empfangen, oder warten Sie, bis nachrichten in der Warteschlange vorhanden sind.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht, wodurch sie aus der Warteschlange entfernt wird. Nachfolgende Aufrufe von Receive geben die Nachrichten zurück, die in der Warteschlange folgen.

Da diese Methode in einer Transaktionswarteschlange aufgerufen wird, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn die Transaktion zu einem Commit verpflichtet wurde.

Verwenden Sie Peek die -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne sie aus der Warteschlange zu entfernen. 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. Einer Nachricht, die von einem Aufruf Peekvon zurückgegeben wird, ist kein Transaktionskontext zugeordnet. Da Peek keine Nachrichten in der Warteschlange entfernt werden, gibt es kein Rollback durch einen Aufruf von Abort.

Verwenden Sie einen Aufruf von Receive , wenn es akzeptabel ist, dass der aktuelle Thread blockiert wird, während er wartet, bis eine Nachricht in der Warteschlange eingeht. Da diese Überladung der Receive Methode ein unendliches Timeout angibt, wartet die Anwendung möglicherweise unbegrenzt. Wenn die Anwendungsverarbeitung fortgesetzt werden soll, ohne auf die Nachricht zu warten, sollten Sie die asynchrone Methode verwenden BeginReceive.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und des direkten Formats Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

Receive(MessageQueueTransactionType)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.

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

Einer der MessageQueueTransactionType-Werte, der den Typ des Transaktionskontexts beschreibt, der der Meldung zugeordnet werden soll.

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.

Ausnahmen

Fehler beim Zugriff auf eine Message Queuing-Methode.

Der transactionType-Parameter ist keiner der MessageQueueTransactionType-Member.

Beispiele

Das folgende Codebeispiel veranschaulicht die Verwendung von 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 von einer Warteschlange mit einem durch den transactionType Parameter definierten Transaktionskontext zu empfangen, oder warten Sie, bis nachrichten in der Warteschlange vorhanden sind.

Geben Sie Automatic für den transactionType Parameter an, wenn bereits ein externer Transaktionskontext an den Thread angefügt ist, den Sie zum Empfangen der Nachricht verwenden möchten. Geben Sie an Single , ob Sie die Nachricht als einzelne interne Transaktion empfangen möchten. Sie können angeben None , ob Sie eine Nachricht von einer Transaktionswarteschlange außerhalb eines Transaktionskontexts empfangen möchten.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht und entfernt sie dadurch aus der Warteschlange. Nachfolgende Aufrufe von Receive geben die folgenden Nachrichten in der Warteschlange zurück.

Wenn diese Methode aufgerufen wird, um eine Nachricht von einer Transaktionswarteschlange zu empfangen, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn ein Commit für die Transaktion ausgeführt wird.

Verwenden Sie die -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne sie aus der Peek Warteschlange zu entfernen. 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 eingetroffen. Es gibt keinen Transaktionskontext, der einer Nachricht zugeordnet ist, die von einem Aufruf Peekvon zurückgegeben wird. Da Peek keine Nachrichten in der Warteschlange entfernt werden, gibt es kein Rollback durch einen Aufruf von Abort.

Verwenden Sie einen Aufruf von Receive , wenn es akzeptabel ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft. Da diese Überladung der Receive -Methode ein unbegrenztes Timeout angibt, kann die Anwendung unbegrenzt warten. Wenn die Anwendungsverarbeitung fortgesetzt werden soll, ohne auf die Nachricht zu warten, sollten Sie die asynchrone Methode BeginReceiveverwenden.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

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.

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

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.

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.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Das folgende Codebeispiel empfängt eine Nachricht aus einer Warteschlange und gibt Informationen zu dieser Nachricht an den Bildschirm aus. Im Beispiel wird die Ausführung für bis zu fünf Sekunden angehalten, während auf das Eintreffen einer Nachricht in der Warteschlange gewartet wird.

#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.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht und entfernt sie aus der Warteschlange. Nachfolgende Aufrufe von Receive geben die Nachrichten zurück, die in der Warteschlange folgen, oder neue Nachrichten mit höherer Priorität.

Verwenden Sie die -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne sie aus der Peek Warteschlange zu entfernen. 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 eingetroffen.

Verwenden Sie einen Aufruf von Receive , wenn es akzeptabel ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft. Der Thread wird für den angegebenen Zeitraum oder unbegrenzt blockiert, wenn Sie den Wert InfiniteTimeout für den timeout Parameter angegeben haben. Wenn die Anwendungsverarbeitung fortgesetzt werden soll, ohne auf eine Nachricht zu warten, sollten Sie die asynchrone Methode BeginReceiveverwenden.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

Receive(TimeSpan, Cursor)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor);
public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor);
member this.Receive : TimeSpan * System.Messaging.Cursor -> System.Messaging.Message
Public Function Receive (timeout As TimeSpan, cursor As Cursor) As Message

Parameter

timeout
TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.

cursor
Cursor

Ein Cursor, der eine bestimmte Position in der Meldungswarteschlange beibehält.

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.

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.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Mit dieser Überladung können Sie eine Meldung empfangen und nach einer angegebenen Zeitspanne beenden, sofern sich keine Meldungen in der Warteschlange befinden.

Gilt für:

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.

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

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.

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.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.

- oder -

Die Warteschlange ist nicht transaktional.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird die Verwendung dieser Methode veranschaulicht.

#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 Transaktionswarteschlange mithilfe des internen Transaktionskontexts zu empfangen, der durch den transaction Parameter definiert ist, und geben Sie innerhalb eines angegebenen Zeitraums zurück, wenn keine Nachrichten in der Warteschlange vorhanden sind.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht und entfernt sie dadurch aus der Warteschlange. Nachfolgende Aufrufe von Receive geben die folgenden Nachrichten in der Warteschlange zurück.

Da diese Methode in einer Transaktionswarteschlange aufgerufen wird, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn ein Commit für die Transaktion ausgeführt wird.

Verwenden Sie die -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne sie aus der Peek Warteschlange zu entfernen. 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 eingetroffen. Es gibt keinen Transaktionskontext, der einer Nachricht zugeordnet ist, die von einem Aufruf Peekvon zurückgegeben wird. Da Peek keine Nachrichten in der Warteschlange entfernt werden, gibt es kein Rollback durch einen Aufruf von Abort.

Verwenden Sie einen Aufruf von Receive , wenn es akzeptabel ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft. Der Thread wird für den angegebenen Zeitraum oder unbegrenzt blockiert, wenn Sie den Wert InfiniteTimeout für den timeout Parameter angegeben haben. Wenn die Anwendungsverarbeitung fortgesetzt werden soll, ohne auf eine Nachricht zu warten, sollten Sie die asynchrone Methode BeginReceiveverwenden.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

Receive(TimeSpan, MessageQueueTransactionType)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und wartet, bis entweder eine Meldung in der Warteschlange verfügbar ist oder der Timeout abläuft.

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

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.

transactionType
MessageQueueTransactionType

Einer der MessageQueueTransactionType-Werte, der den Typ des Transaktionskontexts beschreibt, der der Meldung zugeordnet werden soll.

Gibt zurück

Eine Message, die auf die erste Meldung in der Warteschlange verweist.

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.

Der transactionType-Parameter ist keiner der MessageQueueTransactionType-Member.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Beispiele

Im folgenden Codebeispiel wird die Verwendung dieser Methode veranschaulicht.


// 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 von einer Warteschlange mithilfe eines durch den transactionType -Parameter definierten Transaktionskontexts zu empfangen und in einem bestimmten Zeitraum zurückzugeben, wenn keine Nachrichten in der Warteschlange vorhanden sind.

Geben Sie Automatic für den transactionType Parameter an, wenn bereits ein externer Transaktionskontext an den Thread angefügt ist, den Sie zum Empfangen der Nachricht verwenden möchten. Geben Sie an Single , ob Sie die Nachricht als einzelne interne Transaktion empfangen möchten. Sie können angeben None , ob Sie eine Nachricht von einer Transaktionswarteschlange außerhalb eines Transaktionskontexts empfangen möchten.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht und entfernt sie dadurch aus der Warteschlange. Nachfolgende Aufrufe von Receive geben die folgenden Nachrichten in der Warteschlange zurück.

Wenn diese Methode aufgerufen wird, um eine Nachricht von einer Transaktionswarteschlange zu empfangen, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn ein Commit für die Transaktion ausgeführt wird.

Verwenden Sie die -Methode, um die erste Nachricht in einer Warteschlange zu lesen, ohne sie aus der Peek Warteschlange zu entfernen. 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 eingetroffen. Es gibt keinen Transaktionskontext, der einer Nachricht zugeordnet ist, die von einem Aufruf Peekvon zurückgegeben wird. Da Peek keine Nachrichten in der Warteschlange entfernt werden, gibt es kein Rollback durch einen Aufruf von Abort.

Verwenden Sie einen Aufruf von Receive , wenn es akzeptabel ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft. Der Thread wird für den angegebenen Zeitraum oder unbegrenzt blockiert, wenn Sie den Wert InfiniteTimeout für den timeout Parameter angegeben haben. Wenn die Anwendungsverarbeitung fortgesetzt werden soll, ohne auf eine Nachricht zu warten, sollten Sie die asynchrone Methode BeginReceiveverwenden.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::MessageQueueTransaction ^ transaction);
public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.MessageQueueTransaction transaction);
member this.Receive : TimeSpan * System.Messaging.Cursor * System.Messaging.MessageQueueTransaction -> System.Messaging.Message
Public Function Receive (timeout As TimeSpan, cursor As Cursor, transaction As MessageQueueTransaction) As Message

Parameter

timeout
TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.

cursor
Cursor

Ein Cursor, der eine bestimmte Position in der Meldungswarteschlange beibehält.

Gibt zurück

Eine Message, die auf eine Meldung in der Warteschlange verweist.

Ausnahmen

Der cursor-Parameter ist null.

- oder -

Der transaction-Parameter ist null.

Der für den timeout-Parameter angegebene Wert ist nicht gültig. Möglicherweise ist timeout kleiner als Zero oder größer als InfiniteTimeout.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.

- oder -

Die Warteschlange ist nicht transaktional.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Hinweise

Verwenden Sie diese Überladung, um eine Nachricht aus einer Transaktionswarteschlange mithilfe des internen Transaktionskontexts zu empfangen, der durch den transaction Parameter definiert ist, und geben Sie innerhalb eines angegebenen Zeitraums zurück, wenn keine Nachrichten in der Warteschlange vorhanden sind.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht und entfernt sie dadurch aus der Warteschlange. Nachfolgende Aufrufe, um Receive die folgenden Nachrichten in der Warteschlange zurückzugeben.

Da diese Methode in einer Transaktionswarteschlange aufgerufen wird, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn ein Commit für die Transaktion ausgeführt wird.

Verwenden Sie die -Methode, um eine Nachricht in einer Warteschlange zu lesen, ohne sie aus der Peek Warteschlange zu entfernen. Es gibt keinen Transaktionskontext, der einer Nachricht zugeordnet ist, die von einem Aufruf Peekvon zurückgegeben wird. Da Peek keine Nachrichten in der Warteschlange entfernt werden, gibt es kein Rollback durch einen Aufruf von Abort.

Verwenden Sie einen Aufruf von Receive , wenn es akzeptabel ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft. Der Thread wird für den angegebenen Zeitraum oder unbegrenzt blockiert, wenn Sie den Wert InfiniteTimeout für den timeout Parameter angegeben haben. Wenn die Anwendungsverarbeitung fortgesetzt werden soll, ohne auf eine Nachricht zu warten, sollten Sie die asynchrone Methode BeginReceiveverwenden.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::MessageQueueTransactionType transactionType);
public System.Messaging.Message Receive (TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.MessageQueueTransactionType transactionType);
member this.Receive : TimeSpan * System.Messaging.Cursor * System.Messaging.MessageQueueTransactionType -> System.Messaging.Message
Public Function Receive (timeout As TimeSpan, cursor As Cursor, transactionType As MessageQueueTransactionType) As Message

Parameter

timeout
TimeSpan

Eine TimeSpan, die die Zeitspanne angibt, für die auf den Eingang einer neuen Meldung zur Überprüfung gewartet werden soll.

cursor
Cursor

Ein Cursor, der eine bestimmte Position in der Meldungswarteschlange beibehält.

transactionType
MessageQueueTransactionType

Einer der MessageQueueTransactionType-Werte, der den Typ des Transaktionskontexts beschreibt, der der Meldung zugeordnet werden soll.

Gibt zurück

Eine Message, die auf eine Meldung in der Warteschlange verweist.

Ausnahmen

Der cursor-Parameter ist null.

Der für den timeout-Parameter angegebene Wert ist nicht gültig. Möglicherweise ist timeout kleiner als Zero oder größer als InfiniteTimeout.

Der transactionType-Parameter ist keiner der MessageQueueTransactionType-Member.

Vor Ablauf des Timeouts ist keine Meldung in der Warteschlange eingegangen.

- oder -

Fehler beim Zugriff auf eine Message Queuing-Methode.

Hinweise

Verwenden Sie diese Überladung, um eine Nachricht von einer Warteschlange mithilfe eines durch den transactionType -Parameter definierten Transaktionskontexts zu empfangen und in einem bestimmten Zeitraum zurückzugeben, wenn keine Nachrichten in der Warteschlange vorhanden sind.

Geben Sie Automatic für den transactionType Parameter an, wenn bereits ein externer Transaktionskontext an den Thread angefügt ist, den Sie zum Empfangen der Nachricht verwenden möchten. Geben Sie an Single , ob Sie die Nachricht als einzelne interne Transaktion empfangen möchten. Sie können angeben None , ob Sie eine Nachricht von einer Transaktionswarteschlange außerhalb eines Transaktionskontexts empfangen möchten.

Die Receive -Methode ermöglicht das synchrone Lesen einer Nachricht und entfernt sie dadurch aus der Warteschlange. Nachfolgende Aufrufe, um Receive die folgenden Nachrichten in der Warteschlange zurückzugeben.

Wenn diese Methode aufgerufen wird, um eine Nachricht von einer Transaktionswarteschlange zu empfangen, wird die empfangene Nachricht an die Warteschlange zurückgegeben, wenn die Transaktion abgebrochen wird. Die Nachricht wird erst endgültig aus der Warteschlange entfernt, wenn ein Commit für die Transaktion ausgeführt wird.

Verwenden Sie die -Methode, um eine Nachricht in einer Warteschlange zu lesen, ohne sie aus der Peek Warteschlange zu entfernen. Es gibt keinen Transaktionskontext, der einer Nachricht zugeordnet ist, die von einem Aufruf Peekvon zurückgegeben wird. Da Peek keine Nachrichten in der Warteschlange entfernt werden, gibt es kein Rollback durch einen Aufruf von Abort.

Verwenden Sie einen Aufruf von Receive , wenn es akzeptabel ist, dass der aktuelle Thread blockiert wird, während er darauf wartet, dass eine Nachricht in der Warteschlange eintrifft. Der Thread wird für den angegebenen Zeitraum oder unbegrenzt blockiert, wenn Sie den Wert InfiniteTimeout für den timeout Parameter angegeben haben. Wenn die Anwendungsverarbeitung fortgesetzt werden soll, ohne auf eine Nachricht zu warten, sollten Sie die asynchrone Methode BeginReceiveverwenden.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus Verfügbar
Lokalem Computer Ja
Name des lokalen Computers und direktes Format Ja
Remotecomputer Nein
Name des Remotecomputers und des direkten Formats Ja

Weitere Informationen

Gilt für:

Threadsicherheit

Die -Methode ist nicht threadsicher.