MessageQueue.Receive Méthode

Référence

Définition

Espace de noms:: System.Messaging

Assembly:: System.Messaging.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Reçoit (et supprime) le premier message figurant dans la file d'attente.

Surcharges

Receive()	Reçoit le premier message disponible dans la file référencée par MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.
Receive(MessageQueueTransaction)	Reçoit le premier message disponible dans la file d'attente transactionnelle référencée par MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.
Receive(MessageQueueTransactionType)	Reçoit le premier message disponible dans la file référencée par MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.
Receive(TimeSpan)	Reçoit le premier message disponible dans la file d'attente référencée par MessageQueue et attend qu'un message soit disponible dans la file ou que le délai d'attente expire.
Receive(TimeSpan, Cursor)	Reçoit le message en cours dans la file d'attente, à l'aide d'un curseur spécifié. Si aucun message n'est disponible, cette méthode attend qu'un message soit disponible ou que le délai d'attente expire.
Receive(TimeSpan, MessageQueueTransaction)	Reçoit le premier message disponible dans la file d'attente transactionnelle référencée par MessageQueue et attend qu'un message soit disponible dans la file d'attente ou que le délai d'attente expire.
Receive(TimeSpan, MessageQueueTransactionType)	Reçoit le premier message disponible dans la file référencée par MessageQueue. Cet appel est synchrone et attend qu'un message soit disponible dans la file d'attente ou que le délai expire.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Reçoit le message en cours dans la file d'attente, à l'aide d'un curseur spécifié. Si aucun message n'est disponible, cette méthode attend qu'un message soit disponible ou que le délai d'attente expire.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Reçoit le message en cours dans la file d'attente, à l'aide d'un curseur spécifié. Si aucun message n'est disponible, cette méthode attend qu'un message soit disponible ou que le délai d'attente expire.

Receive()

Reçoit le premier message disponible dans la file référencée par MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.

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

public System.Messaging.Message Receive ();

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

Public Function Receive () As Message

Retours

Message

Message référençant le premier message disponible dans la file d'attente.

Exceptions

MessageQueueException

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant reçoit un message d’une file d’attente et génère des informations sur ce message à l’écran.

#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

Remarques

Utilisez cette surcharge pour recevoir un message d’une file d’attente ou attendez qu’il y ait des messages dans la file d’attente.

La Receive méthode permet la lecture synchrone d’un message, ce qui le supprime de la file d’attente. Les appels suivants à Receive retournent les messages qui suivent dans la file d’attente, ou les nouveaux messages de priorité supérieure.

Utilisez un appel à Receive lorsqu’il est acceptable que le thread actuel soit bloqué pendant qu’il attend qu’un message arrive dans la file d’attente. Étant donné que cette surcharge de la Receive méthode spécifie un délai d’attente infini, l’application peut attendre indéfiniment. Si le traitement de l’application doit se poursuivre sans attendre le message, envisagez d’utiliser la méthode asynchrone , BeginReceive.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

S’applique à

Receive(MessageQueueTransaction)

Reçoit le premier message disponible dans la file d'attente transactionnelle référencée par MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.

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

Paramètres

transaction: MessageQueueTransaction

Objet MessageQueueTransaction.

Retours

Message

Message référençant le premier message disponible dans la file d'attente.

Exceptions

MessageQueueException

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

- ou -

La file d'attente n'est pas transactionnelle.

Exemples

L’exemple de code suivant se connecte à une file d’attente transactionnelle sur l’ordinateur local et envoie un message à la file d’attente. Il reçoit ensuite le message qui contient une commande. S’il rencontre une file d’attente non transactionnelle, il lève, exception et restauration de la 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

Remarques

Utilisez cette surcharge pour recevoir un message à partir d’une file d’attente transactionnelle à l’aide du contexte de transaction interne défini par le transaction paramètre, ou attendez qu’il y ait des messages dans la file d’attente.

La Receive méthode permet la lecture synchrone d’un message, ce qui le supprime de la file d’attente. Les appels suivants à Receive retournent les messages qui suivent dans la file d’attente.

Étant donné que cette méthode est appelée sur une file d’attente transactionnelle, le message reçu est retourné à la file d’attente si la transaction est abandonnée. Le message n’est pas supprimé définitivement de la file d’attente tant que la transaction n’est pas validée.

Pour lire le premier message d’une file d’attente sans le supprimer de la file d’attente, utilisez la Peek méthode . Comme Peek la méthode retourne toujours le premier message de la file d’attente, les appels suivants à la méthode retournent le même message, sauf si un message de priorité supérieure arrive dans la file d’attente. Aucun contexte de transaction n’est associé à un message retourné par un appel à Peek. Étant donné que Peek ne supprime aucun message dans la file d’attente, il n’y a rien à restaurer par un appel à Abort.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

S’applique à

Receive(MessageQueueTransactionType)

Reçoit le premier message disponible dans la file référencée par MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.

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

Paramètres

transactionType: MessageQueueTransactionType

Une des valeurs de MessageQueueTransactionType décrivant le type de contexte de transaction à associer au message.

Retours

Message

Message référençant le premier message disponible dans la file d'attente.

Exceptions

MessageQueueException

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

InvalidEnumArgumentException

Le paramètre transactionType ne fait pas partie des membres MessageQueueTransactionType.

Exemples

L'exemple de code suivant montre l'utilisation de 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);

Remarques

Utilisez cette surcharge pour recevoir un message d’une file d’attente à l’aide d’un contexte de transaction défini par le transactionType paramètre, ou attendez qu’il y ait des messages dans la file d’attente.

Spécifiez Automatic pour le transactionType paramètre s’il existe déjà un contexte de transaction externe attaché au thread que vous souhaitez utiliser pour recevoir le message. Spécifiez Single si vous souhaitez recevoir le message en tant que transaction interne unique. Vous pouvez spécifier None si vous souhaitez recevoir un message d’une file d’attente transactionnelle en dehors d’un contexte de transaction.

La Receive méthode permet la lecture synchrone d’un message, le supprimant ainsi de la file d’attente. Les appels suivants à Receive retournent les messages qui suivent dans la file d’attente.

Si cette méthode est appelée pour recevoir un message d’une file d’attente transactionnelle, le message reçu est retourné à la file d’attente si la transaction est abandonnée. Le message n’est pas supprimé définitivement de la file d’attente tant que la transaction n’est pas validée.

Pour lire le premier message d’une file d’attente sans le supprimer de la file d’attente, utilisez la Peek méthode . La Peek méthode retourne toujours le premier message de la file d’attente, de sorte que les appels suivants à la méthode retournent le même message, sauf si un message de priorité plus élevée arrive dans la file d’attente. Aucun contexte de transaction n’est associé à un message retourné par un appel à Peek. Étant donné que Peek ne supprime aucun message dans la file d’attente, il n’y aurait rien à restaurer par un appel à Abort.

Utilisez un appel à Receive lorsqu’il est acceptable que le thread actuel soit bloqué pendant qu’il attend qu’un message arrive dans la file d’attente. Étant donné que cette surcharge de la Receive méthode spécifie un délai d’attente infini, l’application peut attendre indéfiniment. Si le traitement de l’application doit continuer sans attendre le message, envisagez d’utiliser la méthode asynchrone, BeginReceive.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

S’applique à

Receive(TimeSpan)

Reçoit le premier message disponible dans la file d'attente référencée par MessageQueue et attend qu'un message soit disponible dans la file ou que le délai d'attente expire.

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

Paramètres

timeout: TimeSpan

TimeSpan qui indique la durée d'attente avant qu'un nouveau message ne soit accessible pour consultation.

Retours

Message

Message référençant le premier message disponible dans la file d'attente.

Exceptions

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide. Il se peut que timeout soit inférieur à Zero ou supérieur à InfiniteTimeout.

MessageQueueException

Aucun message n'est arrivé dans la file d'attente avant l'expiration du délai d'attente.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant reçoit un message d’une file d’attente et génère des informations sur ce message à l’écran. L’exemple interrompt l’exécution jusqu’à cinq secondes en attendant qu’un message arrive dans la file d’attente.

#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

Remarques

Utilisez cette surcharge pour recevoir un message et effectuer un retour dans un délai spécifié si la file d'attente ne contient aucun message.

La Receive méthode permet la lecture synchrone d’un message, en le supprimant de la file d’attente. Les appels suivants à Receive retournent les messages qui suivent dans la file d’attente, ou de nouveaux messages de priorité plus élevée.

Utilisez un appel à Receive lorsqu’il est acceptable que le thread actuel soit bloqué pendant qu’il attend qu’un message arrive dans la file d’attente. Le thread sera bloqué pendant la période donnée, ou indéfiniment si vous avez spécifié la valeur InfiniteTimeout du timeout paramètre . Si le traitement de l’application doit continuer sans attendre un message, envisagez d’utiliser la méthode asynchrone, BeginReceive.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

S’applique à

Receive(TimeSpan, Cursor)

Reçoit le message en cours dans la file d'attente, à l'aide d'un curseur spécifié. Si aucun message n'est disponible, cette méthode attend qu'un message soit disponible ou que le délai d'attente expire.

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

Paramètres

timeout: TimeSpan

TimeSpan qui indique la durée d'attente avant qu'un nouveau message ne soit accessible pour consultation.

cursor: Cursor

Cursor qui conserve une position spécifique dans la file d'attente de messages.

Retours

Message

Message référençant le premier message disponible dans la file d'attente.

Exceptions

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide. Il se peut que timeout soit inférieur à Zero ou supérieur à InfiniteTimeout.

MessageQueueException

Aucun message n'est arrivé dans la file d'attente avant l'expiration du délai d'attente.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Utilisez cette surcharge pour recevoir un message et effectuer un retour dans un délai spécifié si la file d'attente ne contient aucun message.

S’applique à

Receive(TimeSpan, MessageQueueTransaction)

Reçoit le premier message disponible dans la file d'attente transactionnelle référencée par MessageQueue et attend qu'un message soit disponible dans la file d'attente ou que le délai d'attente expire.

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

Paramètres

timeout: TimeSpan

TimeSpan qui indique la durée d'attente avant qu'un nouveau message ne soit accessible pour consultation.

transaction: MessageQueueTransaction

Objet MessageQueueTransaction.

Retours

Message

Message référençant le premier message disponible dans la file d'attente.

Exceptions

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide. Il se peut que timeout soit inférieur à Zero ou supérieur à InfiniteTimeout.

MessageQueueException

Aucun message n'est arrivé dans la file d'attente avant l'expiration du délai d'attente.

- ou -

La file d'attente n'est pas transactionnelle.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant illustre l’utilisation de cette méthode.

#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

Remarques

Utilisez cette surcharge pour recevoir un message à partir d’une file d’attente transactionnelle à l’aide du contexte de transaction interne défini par le transaction paramètre et retourner dans un délai spécifié s’il n’y a pas de messages dans la file d’attente.

Étant donné que cette méthode est appelée dans une file d’attente transactionnelle, le message reçu est retourné à la file d’attente si la transaction est abandonnée. Le message n’est pas supprimé définitivement de la file d’attente tant que la transaction n’est pas validée.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

S’applique à

Receive(TimeSpan, MessageQueueTransactionType)

Reçoit le premier message disponible dans la file référencée par MessageQueue. Cet appel est synchrone et attend qu'un message soit disponible dans la file d'attente ou que le délai expire.

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

Paramètres

timeout: TimeSpan

TimeSpan qui indique la durée d'attente avant qu'un nouveau message ne soit accessible pour consultation.

transactionType: MessageQueueTransactionType

Une des valeurs de MessageQueueTransactionType décrivant le type de contexte de transaction à associer au message.

Retours

Message

Message référençant le premier message disponible dans la file d'attente.

Exceptions

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide. Il se peut que timeout soit inférieur à Zero ou supérieur à InfiniteTimeout.

InvalidEnumArgumentException

Le paramètre transactionType ne fait pas partie des membres MessageQueueTransactionType.

MessageQueueException

Aucun message n'est arrivé dans la file d'attente avant l'expiration du délai d'attente.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L’exemple de code suivant illustre l’utilisation de cette méthode.


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

Remarques

Utilisez cette surcharge pour recevoir un message à partir d’une file d’attente à l’aide d’un contexte de transaction défini par le transactionType paramètre et retourner dans un laps de temps spécifié s’il n’y a aucun message dans la file d’attente.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

S’applique à

Receive(TimeSpan, Cursor, MessageQueueTransaction)

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

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

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

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

Paramètres

timeout: TimeSpan

TimeSpan qui indique la durée d'attente avant qu'un nouveau message ne soit accessible pour consultation.

cursor: Cursor

Cursor qui conserve une position spécifique dans la file d'attente de messages.

transaction: MessageQueueTransaction

Objet MessageQueueTransaction.

Retours

Message

Message qui référence un message dans la file d'attente.

Exceptions

ArgumentNullException

Le paramètre cursor a la valeur null.

- ou -

Le paramètre transaction a la valeur null.

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide. Il est possible que timeout soit inférieur à Zero ou supérieur à InfiniteTimeout.

MessageQueueException

Aucun message n'est arrivé dans la file d'attente avant l'expiration du délai d'attente.

- ou -

La file d'attente n'est pas transactionnelle.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Remarques

Utilisez cette surcharge pour recevoir un message à partir d’une file d’attente transactionnelle à l’aide du contexte de transaction interne défini par le transaction paramètre et retourner dans un délai spécifié s’il n’y a pas de messages dans la file d’attente.

La Receive méthode permet la lecture synchrone d’un message, le supprimant ainsi de la file d’attente. Appels suivants pour Receive retourner les messages qui suivent dans la file d’attente.

Pour lire un message dans une file d’attente sans le supprimer de la file d’attente, utilisez la Peek méthode . Aucun contexte de transaction n’est associé à un message retourné par un appel à Peek. Étant donné que Peek ne supprime aucun message dans la file d’attente, il n’y a rien à restaurer par un appel à Abort.

Utilisez un appel à Receive lorsqu’il est acceptable que le thread actuel soit bloqué pendant qu’il attend qu’un message arrive dans la file d’attente. Le thread est bloqué pendant la période donnée, ou indéfiniment si vous avez spécifié la valeur InfiniteTimeout du timeout paramètre . Si le traitement de l’application doit continuer sans attendre un message, envisagez d’utiliser la méthode asynchrone, BeginReceive.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

S’applique à

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

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

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

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

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

Paramètres

timeout: TimeSpan

TimeSpan qui indique la durée d'attente avant qu'un nouveau message ne soit accessible pour consultation.

cursor: Cursor

Cursor qui conserve une position spécifique dans la file d'attente de messages.

transactionType: MessageQueueTransactionType

Une des valeurs de MessageQueueTransactionType qui décrit le type de contexte de transaction à associer au message.

Retours

Message

Message qui référence un message dans la file d'attente.

Exceptions

ArgumentNullException

Le paramètre cursor a la valeur null.

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide. Il est possible que timeout soit inférieur à Zero ou supérieur à InfiniteTimeout.

InvalidEnumArgumentException

Le paramètre transactionType ne fait pas partie des membres MessageQueueTransactionType.

MessageQueueException

Aucun message n'est arrivé dans la file d'attente avant l'expiration du délai d'attente.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Remarques

La Receive méthode permet la lecture synchrone d’un message, le supprimant ainsi de la file d’attente. Appels suivants pour Receive retourner les messages qui suivent dans la file d’attente.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

S’applique à

Cohérence de thread

La méthode n’est pas thread safe.

Partager via

MessageQueue.Receive Méthode

Définition

Surcharges

Receive()

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Receive(MessageQueueTransaction)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Receive(MessageQueueTransactionType)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Receive(TimeSpan)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Receive(TimeSpan, Cursor)

Paramètres

Retours

Exceptions

S’applique à

Receive(TimeSpan, MessageQueueTransaction)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Receive(TimeSpan, MessageQueueTransactionType)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Paramètres

Retours

Exceptions

Remarques

Voir aussi

S’applique à

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Paramètres

Retours

Exceptions

Remarques

Voir aussi

S’applique à

Cohérence de thread

Ressources supplémentaires