Partager via

MessageQueue.BeginReceive Méthode

Définition

Espace de noms:
System.Messaging
Assembly:
System.Messaging.dll

Lance une opération de réception asynchrone en indiquant à Message Queuing de commencer à recevoir un message et de notifier le gestionnaire d’événements une fois terminé.

Surcharges

Nom Description
BeginReceive()

Lance une opération de réception asynchrone qui n’a pas de délai d’attente. L’opération n’est pas terminée tant qu’un message n’est pas disponible dans la file d’attente.
BeginReceive(TimeSpan)

Lance une opération de réception asynchrone qui a un délai d’attente spécifié. L’opération n’est pas terminée tant qu’un message n’est pas disponible dans la file d’attente ou que le délai d’attente se produit.
BeginReceive(TimeSpan, Object)

Lance une opération de réception asynchrone qui a un délai d’attente spécifié et un objet d’état spécifié, qui fournit des informations associées tout au long de la durée de vie de l’opération. L’opération n’est pas terminée tant qu’un message n’est pas disponible dans la file d’attente ou que le délai d’attente se produit.
BeginReceive(TimeSpan, Object, AsyncCallback)

Lance une opération de réception asynchrone qui a un délai d’attente spécifié et un objet d’état spécifié, qui fournit des informations associées tout au long de la durée de vie de l’opération. Cette surcharge reçoit la notification, via un rappel, de l’identité du gestionnaire d’événements pour l’opération. L’opération n’est pas terminée tant qu’un message n’est pas disponible dans la file d’attente ou que le délai d’attente se produit.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Lance une opération de réception asynchrone qui a un délai d’attente spécifié et utilise un curseur spécifié et un objet d’état spécifié. L’objet d’état fournit des informations associées tout au long de la durée de vie de l’opération. Cette surcharge reçoit la notification, via un rappel, de l’identité du gestionnaire d’événements pour l’opération. L’opération n’est pas terminée tant qu’un message n’est pas disponible dans la file d’attente ou que le délai d’attente se produit.

BeginReceive()

Lance une opération de réception asynchrone qui n’a pas de délai d’attente. L’opération n’est pas terminée tant qu’un message n’est pas disponible dans la file d’attente.

public:
 IAsyncResult ^ BeginReceive();
public IAsyncResult BeginReceive();
member this.BeginReceive : unit -> IAsyncResult
Public Function BeginReceive () As IAsyncResult

Retours

IAsyncResult

Qui IAsyncResult identifie la demande asynchrone publiée.

Exceptions

MessageQueueException

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

Exemples

L’exemple de code suivant chaîne les requêtes asynchrones. Il suppose qu’il existe une file d’attente sur l’ordinateur local appelé « myQueue ». La Main fonction commence l’opération asynchrone gérée par la MyReceiveCompleted routine. MyReceiveCompleted traite le message actuel et commence une nouvelle opération de réception asynchrone.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Define static class members.
   static ManualResetEvent^ signal = gcnew ManualResetEvent( false );
   static int count = 0;

   // Provides an event handler for the ReceiveCompleted
   // event.
   static void MyReceiveCompleted( Object^ source, ReceiveCompletedEventArgs^ asyncResult )
   {
      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );
         count += 1;
         if ( count == 10 )
         {
            signal->Set();
         }

         // Restart the asynchronous receive operation.
         mq->BeginReceive();
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }

      // Handle other exceptions.
      return;
   }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous receive
// operation processing.
int main()
{
   // Create an instance of MessageQueue. Set its formatter.
   MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

   // Add an event handler for the ReceiveCompleted event.
   myQueue->ReceiveCompleted += gcnew ReceiveCompletedEventHandler( MyNewQueue::MyReceiveCompleted );

   // Begin the asynchronous receive operation.
   myQueue->BeginReceive();
   MyNewQueue::signal->WaitOne();

   // Do other work on the current thread.
   return 0;
}

using System;
using System.Messaging;
using System.Threading;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {
        // Define static class members.
        static ManualResetEvent signal = new ManualResetEvent(false);
        static int count = 0;

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous receive
        // operation processing.
        //**************************************************

        public static void Main()
        {
            // Create an instance of MessageQueue. Set its formatter.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});

            // Add an event handler for the ReceiveCompleted event.
            myQueue.ReceiveCompleted +=
                new ReceiveCompletedEventHandler(MyReceiveCompleted);
            
            // Begin the asynchronous receive operation.
            myQueue.BeginReceive();

            signal.WaitOne();
            
            // Do other work on the current thread.

            return;
        }

        //***************************************************
        // Provides an event handler for the ReceiveCompleted
        // event.
        //***************************************************
        
        private static void MyReceiveCompleted(Object source,
            ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous receive operation.
                Message m = mq.EndReceive(asyncResult.AsyncResult);
                
                count += 1;
                if (count == 10)
                {
                    signal.Set();
                }

                // Restart the asynchronous receive operation.
                mq.BeginReceive();
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}

Imports System.Messaging
Imports System.Threading




' Provides a container class for the example.

Public Class MyNewQueue

        ' Define static class members.
        Private Shared signal As New ManualResetEvent(False)
        Private Shared count As Integer = 0



        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous receive
        ' operation processing.


        Public Shared Sub Main()
            ' Create an instance of MessageQueue. Set its formatter.
            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Add an event handler for the ReceiveCompleted event.
            AddHandler myQueue.ReceiveCompleted, AddressOf _
                MyReceiveCompleted

            ' Begin the asynchronous receive operation.
            myQueue.BeginReceive()

            signal.WaitOne()

            ' Do other work on the current thread.

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

            Try
                ' Connect to the queue.
                Dim mq As MessageQueue = CType([source], MessageQueue)

                ' End the asynchronous receive operation.
                Dim m As Message = _
                    mq.EndReceive(asyncResult.AsyncResult)

                count += 1
                If count = 10 Then
                    signal.Set()
                End If

                ' Restart the asynchronous receive operation.
                mq.BeginReceive()

            Catch
                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

L’exemple de code suivant met en file d’attente des requêtes asynchrones. Appel à BeginReceive utiliser la AsyncWaitHandle valeur renvoyée. La Main routine attend que toutes les opérations asynchrones soient terminées avant de quitter.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Provides an event handler for the ReceiveCompleted
   // event.
   static void MyReceiveCompleted( Object^ source, ReceiveCompletedEventArgs^ asyncResult )
   {
      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );

         // Process the message here.
         Console::WriteLine( "Message received." );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }
      // Handle other exceptions.
      return;
   }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous receive
// operation processing.
int main()
{
   // Create an instance of MessageQueue. Set its formatter.
   MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

   // Add an event handler for the ReceiveCompleted event.
   myQueue->ReceiveCompleted += gcnew ReceiveCompletedEventHandler( MyNewQueue::MyReceiveCompleted );

   // Define wait handles for multiple operations.
   array<WaitHandle^>^waitHandleArray = gcnew array<WaitHandle^>(10);
   for ( int i = 0; i < 10; i++ )
   {
      // Begin asynchronous operations.
      waitHandleArray[ i ] = myQueue->BeginReceive()->AsyncWaitHandle;
   }

   // Specify to wait for all operations to return.
   WaitHandle::WaitAll( waitHandleArray );
   return 0;
}

using System;
using System.Messaging;
using System.Threading;

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

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous receive
        // operation processing.
        //**************************************************

        public static void Main()
        {
            // Create an instance of MessageQueue. Set its formatter.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});

            // Add an event handler for the ReceiveCompleted event.
            myQueue.ReceiveCompleted +=
                new ReceiveCompletedEventHandler(MyReceiveCompleted);
            
            // Define wait handles for multiple operations.
            WaitHandle[] waitHandleArray = new WaitHandle[10];
            for(int i=0; i<10; i++)
            {
                // Begin asynchronous operations.
                waitHandleArray[i] =
                    myQueue.BeginReceive().AsyncWaitHandle;
            }

            // Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray);

            return;
        }

        //***************************************************
        // Provides an event handler for the ReceiveCompleted
        // event.
        //***************************************************
        
        private static void MyReceiveCompleted(Object source,
            ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous receive operation.
                Message m = mq.EndReceive(asyncResult.AsyncResult);
        
                // Process the message here.
                Console.WriteLine("Message received.");
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}

Imports System.Messaging
Imports System.Threading


' Provides a container class for the example.

Public Class MyNewQueue


        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous receive
        ' operation processing.


        Public Shared Sub Main()

            ' Create an instance of MessageQueue. Set its formatter.
            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Add an event handler for the ReceiveCompleted event.
            AddHandler myQueue.ReceiveCompleted, AddressOf _
                MyReceiveCompleted

            ' Define wait handles for multiple operations.
            Dim waitHandleArray(10) As WaitHandle

            Dim i As Integer
            For i = 0 To 9
                ' Begin asynchronous operations.
                waitHandleArray(i) = _
                    myQueue.BeginReceive().AsyncWaitHandle
            Next i

            ' Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray)

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

            Try
                ' Connect to the queue.
                Dim mq As MessageQueue = CType([source], MessageQueue)

                ' End the asynchronous receive operation.
                Dim m As Message = _
                    mq.EndReceive(asyncResult.AsyncResult)

                ' Process the message here.
                Console.WriteLine("Message received.")

            Catch

                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Remarques

Dans le traitement asynchrone, vous utilisez BeginReceive pour déclencher l’événement ReceiveCompleted lorsqu’un message a été supprimé de la file d’attente.

ReceiveCompleted est également déclenché si un message existe déjà dans la file d’attente.

Pour utiliser BeginReceive, créez un gestionnaire d’événements qui traite les résultats de l’opération asynchrone et l’associez à votre délégué d’événement. BeginReceive lance une opération de réception asynchrone ; MessageQueue est averti, par le biais du déclenchement de l’événement ReceiveCompleted , lorsqu’un message arrive dans la file d’attente. Le MessageQueue message peut ensuite accéder au message en appelant EndReceive(IAsyncResult).

La BeginReceive méthode retourne immédiatement, mais l’opération asynchrone n’est pas terminée tant que le gestionnaire d’événements n’est pas appelé.

Étant donné qu’il BeginReceive est asynchrone, vous pouvez l’appeler pour recevoir un message de la file d’attente sans bloquer le thread actuel d’exécution. Pour recevoir de façon synchrone un message, utilisez la Receive méthode.

Une fois qu’une opération asynchrone est terminée, vous pouvez appeler BeginPeek ou BeginReceive à nouveau dans le gestionnaire d’événements pour continuer à recevoir des notifications.

Qui IAsyncResultBeginReceive retourne identifie l’opération asynchrone démarrée par la méthode. Vous pouvez l’utiliser IAsyncResult tout au long de la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle EndReceive(IAsyncResult) n’est pas appelée. Toutefois, si vous démarrez plusieurs opérations asynchrones, vous pouvez placer leurs IAsyncResult valeurs dans un tableau et spécifier s’il faut attendre que toutes les opérations ou toutes les opérations se terminent. Dans ce cas, vous utilisez la AsyncWaitHandle propriété de l’élément IAsyncResult pour identifier l’opération terminée.

Si CanRead c’est falsele cas, l’événement d’achèvement est déclenché, mais une exception est levée lors de l’appel EndReceive(IAsyncResult).

N’utilisez pas l’appel BeginReceive asynchrone avec les transactions. Si vous souhaitez effectuer une opération asynchrone transactionnelle, appelez BeginPeeket placez la transaction et la méthode (synchrone) Receive dans le gestionnaire d’événements que vous créez pour l’opération d’aperçu. Votre gestionnaire d’événements peut contenir des fonctionnalités, comme indiqué dans le code C# suivant.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

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 à

BeginReceive(TimeSpan)

Lance une opération de réception asynchrone qui a un délai d’attente spécifié. L’opération n’est pas terminée tant qu’un message n’est pas disponible dans la file d’attente ou que le délai d’attente se produit.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout);
public IAsyncResult BeginReceive(TimeSpan timeout);
member this.BeginReceive : TimeSpan -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan) As IAsyncResult

Paramètres

timeout
TimeSpan

Indiquant TimeSpan l’intervalle de temps d’attente pour qu’un message devienne disponible.

Retours

IAsyncResult

Qui IAsyncResult identifie la demande asynchrone publiée.

Exceptions

ArgumentException

La valeur spécifiée pour le timeout paramètre n’est pas valide, éventuellement parce qu’elle représente un nombre négatif.

MessageQueueException

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

Exemples

L’exemple de code suivant crée une opération de réception asynchrone. L’exemple de code crée un gestionnaire d’événements et MyReceiveCompletedl’attache au délégué du ReceiveCompleted gestionnaire d’événements. L’exemple de code envoie un message à une file d’attente de messages local, puis appelle BeginReceive(TimeSpan), passant une valeur de délai d’attente de dix secondes. Lorsqu’un événement est déclenché, le gestionnaire d’événements ReceiveCompleted reçoit le message et écrit le corps du message à l’écran.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message body: {0}", msg->Body);
    
    queue->Close();
}

int main()
{
    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

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

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0));

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }

    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }

}


using System;
using System.Messaging;

public class QueueExample
{
    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

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

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
                ReceiveCompletedEventHandler(MyReceiveCompleted);

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0));

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(Object source,
        ReceiveCompletedEventArgs asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = (MessageQueue)source;

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Remarques

Dans le traitement asynchrone, vous utilisez BeginReceive pour déclencher l’événement ReceiveCompleted lorsqu’un message devient disponible dans la file d’attente ou lorsque l’intervalle de temps spécifié a expiré.

ReceiveCompleted est également déclenché si un message existe déjà dans la file d’attente.

Pour utiliser BeginReceive, créez un gestionnaire d’événements qui traite les résultats de l’opération asynchrone et l’associez à votre délégué d’événement. BeginReceive lance une opération de réception asynchrone ; MessageQueue est averti, par le biais du déclenchement de l’événement ReceiveCompleted , lorsqu’un message arrive dans la file d’attente. Il MessageQueue peut ensuite accéder au message en appelant EndReceive(IAsyncResult) ou en récupérant le résultat à l’aide du ReceiveCompletedEventArgs.

La BeginReceive méthode retourne immédiatement, mais l’opération asynchrone n’est pas terminée tant que le gestionnaire d’événements n’est pas appelé.

Étant donné qu’il BeginReceive est asynchrone, vous pouvez l’appeler pour recevoir un message de la file d’attente sans bloquer le thread actuel d’exécution. Pour recevoir de façon synchrone un message, utilisez la Receive méthode.

Une fois qu’une opération asynchrone est terminée, vous pouvez appeler BeginPeek ou BeginReceive à nouveau dans le gestionnaire d’événements pour continuer à recevoir des notifications.

Si CanRead c’est falsele cas, l’événement d’achèvement est déclenché, mais une exception est levée lors de l’appel EndReceive(IAsyncResult).

Qui IAsyncResultBeginReceive retourne identifie l’opération asynchrone démarrée par la méthode. Vous pouvez l’utiliser IAsyncResult tout au long de la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle EndReceive(IAsyncResult) n’est pas appelée. Toutefois, si vous démarrez plusieurs opérations asynchrones, vous pouvez placer leurs IAsyncResult valeurs dans un tableau et spécifier s’il faut attendre que toutes les opérations ou toutes les opérations se terminent. Dans ce cas, vous utilisez la AsyncWaitHandle propriété de l’élément IAsyncResult pour identifier l’opération terminée.

Cette surcharge spécifie un délai d’attente. Si l’intervalle spécifié par le timeout paramètre expire, ce composant déclenche l’événement ReceiveCompleted . Étant donné qu’aucun message n’existe, un appel ultérieur à EndReceive(IAsyncResult) levera une exception.

N’utilisez pas l’appel BeginReceive asynchrone avec les transactions. Si vous souhaitez effectuer une opération asynchrone transactionnelle, appelez BeginPeeket placez la transaction et la méthode (synchrone) Receive dans le gestionnaire d’événements que vous créez pour l’opération d’aperçu. Votre gestionnaire d’événements peut contenir des fonctionnalités, comme indiqué dans le code C# suivant.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

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 à

BeginReceive(TimeSpan, Object)

Lance une opération de réception asynchrone qui a un délai d’attente spécifié et un objet d’état spécifié, qui fournit des informations associées tout au long de la durée de vie de l’opération. L’opération n’est pas terminée tant qu’un message n’est pas disponible dans la file d’attente ou que le délai d’attente se produit.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject);
public IAsyncResult BeginReceive(TimeSpan timeout, object stateObject);
member this.BeginReceive : TimeSpan * obj -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan, stateObject As Object) As IAsyncResult

Paramètres

timeout
TimeSpan

Indiquant TimeSpan l’intervalle de temps d’attente pour qu’un message devienne disponible.

stateObject
Object

Objet d’état, spécifié par l’application, qui contient des informations associées à l’opération asynchrone.

Retours

IAsyncResult

Qui IAsyncResult identifie la demande asynchrone publiée.

Exceptions

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide.

MessageQueueException

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

Exemples

L’exemple de code suivant crée une opération de réception asynchrone. L’exemple de code crée un gestionnaire d’événements et MyReceiveCompletedl’attache au délégué du ReceiveCompleted gestionnaire d’événements. L’exemple de code envoie un message à une file d’attente de messages local, puis appelle BeginReceive(TimeSpan, Object), passant une valeur de délai d’attente de dix secondes et un entier unique qui identifie ce message particulier. Lorsqu’un événement est déclenché, le gestionnaire d’événements ReceiveCompleted reçoit le message et écrit le corps du message et l’identificateur de message entier à l’écran.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", e->AsyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    queue->Close();
}

int main()
{
    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;

    // Represents a state object associated with each message.
    int messageNumber = 0;

    try
    {
        CreateQueue(".\\exampleQueue", false);

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

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++);

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }
}


using System;
using System.Messaging;

public class QueueExample
{
    // Represents a state object associated with each message.
    static int messageNumber = 0;

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

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

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
            ReceiveCompletedEventHandler(MyReceiveCompleted);

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++);

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(Object source,
        ReceiveCompletedEventArgs asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = (MessageQueue)source;

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}",
            (int)asyncResult.AsyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Remarques

Dans le traitement asynchrone, vous utilisez BeginReceive pour déclencher l’événement ReceiveCompleted lorsqu’un message devient disponible dans la file d’attente ou lorsque l’intervalle de temps spécifié a expiré.

ReceiveCompleted est également déclenché si un message existe déjà dans la file d’attente.

Utilisez cette surcharge pour associer des informations à l’opération qui seront conservées pendant toute la durée de vie de l’opération. Le gestionnaire d’événements peut détecter ces informations en examinant la AsyncState propriété du gestionnaire d’événements IAsyncResult associé à l’opération.

Pour utiliser BeginReceive, créez un gestionnaire d’événements qui traite les résultats de l’opération asynchrone et l’associez à votre délégué d’événement. BeginReceive lance une opération de réception asynchrone ; MessageQueue est averti, par le biais du déclenchement de l’événement ReceiveCompleted , lorsqu’un message arrive dans la file d’attente. Il MessageQueue peut ensuite accéder au message en appelant EndReceive(IAsyncResult) ou en récupérant le résultat à l’aide du ReceiveCompletedEventArgs.

La BeginReceive méthode retourne immédiatement, mais l’opération asynchrone n’est pas terminée tant que le gestionnaire d’événements n’est pas appelé.

Étant donné qu’il BeginReceive est asynchrone, vous pouvez l’appeler pour recevoir un message de la file d’attente sans bloquer le thread actuel d’exécution. Pour recevoir de façon synchrone un message, utilisez la Receive méthode.

Une fois qu’une opération asynchrone est terminée, vous pouvez appeler BeginPeek ou BeginReceive à nouveau dans le gestionnaire d’événements pour continuer à recevoir des notifications.

Qui IAsyncResultBeginReceive retourne identifie l’opération asynchrone démarrée par la méthode. Vous pouvez l’utiliser IAsyncResult tout au long de la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle EndReceive(IAsyncResult) n’est pas appelée. Toutefois, si vous démarrez plusieurs opérations asynchrones, vous pouvez placer leurs IAsyncResult valeurs dans un tableau et spécifier s’il faut attendre que toutes les opérations ou toutes les opérations se terminent. Dans ce cas, vous utilisez la AsyncWaitHandle propriété de l’élément IAsyncResult pour identifier l’opération terminée.

Cette surcharge spécifie un délai d’attente et un objet d’état. Si l’intervalle spécifié par le timeout paramètre expire, ce composant déclenche l’événement ReceiveCompleted . Étant donné qu’aucun message n’existe, un appel ultérieur à EndReceive(IAsyncResult) levera une exception.

L’objet d’état associe les informations d’état à l’opération. Par exemple, si vous appelez BeginReceive plusieurs fois pour lancer plusieurs opérations, vous pouvez identifier chaque opération par le biais d’un objet d’état distinct que vous définissez.

Vous pouvez également utiliser l’objet d’état pour transmettre des informations sur les threads de processus. Si un thread est démarré mais que le rappel se trouve sur un autre thread dans un scénario asynchrone, l’objet d’état est marshalé et repassé avec les informations de l’événement.

N’utilisez pas l’appel BeginReceive asynchrone avec les transactions. Si vous souhaitez effectuer une opération asynchrone transactionnelle, appelez BeginPeeket placez la transaction et la méthode (synchrone) Receive dans le gestionnaire d’événements que vous créez pour l’opération d’aperçu. Votre gestionnaire d’événements peut contenir des fonctionnalités, comme indiqué dans le code C# suivant.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

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 à

BeginReceive(TimeSpan, Object, AsyncCallback)

Lance une opération de réception asynchrone qui a un délai d’attente spécifié et un objet d’état spécifié, qui fournit des informations associées tout au long de la durée de vie de l’opération. Cette surcharge reçoit la notification, via un rappel, de l’identité du gestionnaire d’événements pour l’opération. L’opération n’est pas terminée tant qu’un message n’est pas disponible dans la file d’attente ou que le délai d’attente se produit.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject, AsyncCallback ^ callback);
public IAsyncResult BeginReceive(TimeSpan timeout, object stateObject, AsyncCallback callback);
member this.BeginReceive : TimeSpan * obj * AsyncCallback -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan, stateObject As Object, callback As AsyncCallback) As IAsyncResult

Paramètres

timeout
TimeSpan

Indiquant TimeSpan l’intervalle de temps d’attente pour qu’un message devienne disponible.

stateObject
Object

Objet d’état, spécifié par l’application, qui contient des informations associées à l’opération asynchrone.

callback
AsyncCallback

Qui AsyncCallback recevra la notification de l’achèvement de l’opération asynchrone.

Retours

IAsyncResult

Qui IAsyncResult identifie la demande asynchrone publiée.

Exceptions

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide.

MessageQueueException

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

Exemples

L’exemple de code suivant crée une opération de réception asynchrone. L’exemple de code envoie un message à une file d’attente de messages local, puis appelle BeginReceive(TimeSpan, Object, AsyncCallback), en passant : une valeur de délai d’attente de dix secondes ; un entier unique qui identifie ce message particulier ; et une nouvelle instance de AsyncCallback ce qui identifie le gestionnaire d’événements. MyReceiveCompleted Lorsqu’un événement est déclenché, le gestionnaire d’événements ReceiveCompleted reçoit le message et écrit le corps du message et l’identificateur de message entier à l’écran.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if (!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(IAsyncResult^ asyncResult)
{
    // Connect to the queue.
    MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(asyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", asyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    queue->Close();
}

int main()
{
    // Represents a state object associated with each message.
    int messageNumber = 0;

    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

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

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++,
            gcnew AsyncCallback(HandleReceiveCompleted));

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }
}


using System;
using System.Messaging;

public class QueueExample
{
    // Represents a state object associated with each message.
    static int messageNumber = 0;

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

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

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++,
            new AsyncCallback(MyReceiveCompleted));
            
        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(IAsyncResult asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}", (int)asyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Remarques

Lorsque vous utilisez cette surcharge, le rappel spécifié dans le paramètre de rappel est appelé directement lorsqu’un message devient disponible dans la file d’attente ou lorsque l’intervalle de temps spécifié a expiré ; l’événement ReceiveCompleted n’est pas déclenché. Les autres surcharges de BeginReceive s’appuyer sur ce composant pour déclencher l’événement ReceiveCompleted .

ReceiveCompleted est également déclenché si un message existe déjà dans la file d’attente.

Pour utiliser BeginReceive, créez un gestionnaire d’événements qui traite les résultats de l’opération asynchrone et l’associez à votre délégué d’événement. BeginReceive lance une opération de réception asynchrone ; MessageQueue est averti, par le biais du déclenchement de l’événement ReceiveCompleted , lorsqu’un message arrive dans la file d’attente. Il MessageQueue peut ensuite accéder au message en appelant EndReceive(IAsyncResult) ou en récupérant le résultat à l’aide du ReceiveCompletedEventArgs.

La BeginReceive méthode retourne immédiatement, mais l’opération asynchrone n’est pas terminée tant que le gestionnaire d’événements n’est pas appelé.

Étant donné qu’il BeginReceive est asynchrone, vous pouvez l’appeler pour recevoir un message de la file d’attente sans bloquer le thread actuel d’exécution. Pour recevoir de façon synchrone un message, utilisez la Receive méthode.

Une fois qu’une opération asynchrone est terminée, vous pouvez appeler BeginPeek ou BeginReceive à nouveau dans le gestionnaire d’événements pour continuer à recevoir des notifications.

Qui IAsyncResultBeginReceive retourne identifie l’opération asynchrone démarrée par la méthode. Vous pouvez l’utiliser IAsyncResult tout au long de la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle EndReceive(IAsyncResult) n’est pas appelée. Toutefois, si vous démarrez plusieurs opérations asynchrones, vous pouvez placer leurs IAsyncResult valeurs dans un tableau et spécifier s’il faut attendre que toutes les opérations ou toutes les opérations se terminent. Dans ce cas, vous utilisez la AsyncWaitHandle propriété de l’élément IAsyncResult pour identifier l’opération terminée.

L’objet d’état associe les informations d’état à l’opération. Par exemple, si vous appelez BeginReceive plusieurs fois pour lancer plusieurs opérations, vous pouvez identifier chaque opération par le biais d’un objet d’état distinct que vous définissez.

Vous pouvez également utiliser l’objet d’état pour transmettre des informations sur les threads de processus. Si un thread est démarré mais que le rappel se trouve sur un autre thread dans un scénario asynchrone, l’objet d’état est marshalé et repassé avec les informations de l’événement.

N’utilisez pas l’appel BeginReceive asynchrone avec les transactions. Si vous souhaitez effectuer une opération asynchrone transactionnelle, appelez BeginPeeket placez la transaction et la méthode (synchrone) Receive dans le gestionnaire d’événements que vous créez pour l’opération d’aperçu. Votre gestionnaire d’événements peut contenir des fonctionnalités, comme indiqué dans le code C# suivant.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

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 à

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Lance une opération de réception asynchrone qui a un délai d’attente spécifié et utilise un curseur spécifié et un objet d’état spécifié. L’objet d’état fournit des informations associées tout au long de la durée de vie de l’opération. Cette surcharge reçoit la notification, via un rappel, de l’identité du gestionnaire d’événements pour l’opération. L’opération n’est pas terminée tant qu’un message n’est pas disponible dans la file d’attente ou que le délai d’attente se produit.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Object ^ state, AsyncCallback ^ callback);
public IAsyncResult BeginReceive(TimeSpan timeout, System.Messaging.Cursor cursor, object state, AsyncCallback callback);
member this.BeginReceive : TimeSpan * System.Messaging.Cursor * obj * AsyncCallback -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan, cursor As Cursor, state As Object, callback As AsyncCallback) As IAsyncResult

Paramètres

timeout
TimeSpan

Indiquant TimeSpan l’intervalle de temps d’attente pour qu’un message devienne disponible.

cursor
Cursor

Qui Cursor conserve une position spécifique dans la file d’attente de messages.

state
Object

Objet d’état, spécifié par l’application, qui contient des informations associées à l’opération asynchrone.

callback
AsyncCallback

AsyncCallback Qui reçoit la notification de l’achèvement de l’opération asynchrone.

Retours

IAsyncResult

Qui IAsyncResult identifie la demande asynchrone publiée.

Exceptions

ArgumentNullException

Le cursor paramètre est null.

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide.

MessageQueueException

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

Remarques

Lorsque vous utilisez cette surcharge, le rappel spécifié dans le paramètre de rappel est appelé directement lorsqu’un message devient disponible dans la file d’attente ou lorsque l’intervalle de temps spécifié a expiré ; l’événement ReceiveCompleted n’est pas déclenché. Les autres surcharges de BeginReceive s’appuyer sur ce composant pour déclencher l’événement ReceiveCompleted .

ReceiveCompleted est également déclenché si un message existe déjà dans la file d’attente.

Pour utiliser BeginReceive, créez un gestionnaire d’événements qui traite les résultats de l’opération asynchrone et l’associez à votre délégué d’événement. BeginReceive lance une opération de réception asynchrone ; MessageQueue est averti, par le biais du déclenchement de l’événement ReceiveCompleted , lorsqu’un message arrive dans la file d’attente. Il MessageQueue peut ensuite accéder au message en appelant EndReceive(IAsyncResult) ou en récupérant le résultat à l’aide du ReceiveCompletedEventArgs.

La BeginReceive méthode retourne immédiatement, mais l’opération asynchrone n’est pas terminée tant que le gestionnaire d’événements n’est pas appelé.

Étant donné qu’il BeginReceive est asynchrone, vous pouvez l’appeler pour recevoir un message de la file d’attente sans bloquer le thread actuel d’exécution. Pour recevoir de façon synchrone un message, utilisez la Receive méthode.

Une fois qu’une opération asynchrone est terminée, vous pouvez appeler BeginPeek ou BeginReceive à nouveau dans le gestionnaire d’événements pour continuer à recevoir des notifications.

Qui IAsyncResultBeginReceive retourne identifie l’opération asynchrone démarrée par la méthode. Vous pouvez l’utiliser IAsyncResult tout au long de la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle EndReceive(IAsyncResult) n’est pas appelée. Toutefois, si vous démarrez plusieurs opérations asynchrones, vous pouvez placer leurs IAsyncResult valeurs dans un tableau et spécifier s’il faut attendre que toutes les opérations ou toutes les opérations se terminent. Dans ce cas, utilisez la AsyncWaitHandle propriété de l’élément IAsyncResult pour identifier l’opération terminée.

L’objet d’état associe les informations d’état à l’opération. Par exemple, si vous appelez BeginReceive plusieurs fois pour lancer plusieurs opérations, vous pouvez identifier chaque opération par le biais d’un objet d’état distinct que vous définissez.

Vous pouvez également utiliser l’objet d’état pour transmettre des informations sur les threads de processus. Si un thread est démarré mais que le rappel se trouve sur un autre thread dans un scénario asynchrone, l’objet d’état est marshalé et repassé avec les informations de l’événement.

N’utilisez pas l’appel BeginReceive asynchrone avec les transactions. Si vous souhaitez effectuer une opération asynchrone transactionnelle, appelez BeginPeeket placez la transaction et la méthode (synchrone) Receive dans le gestionnaire d’événements que vous créez pour l’opération d’aperçu. Votre gestionnaire d’événements peut contenir des fonctionnalités, comme indiqué dans le code C# suivant.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

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.