MessageQueue.BeginReceive Méthode

public:
 IAsyncResult ^ BeginReceive();

public IAsyncResult BeginReceive ();

member this.BeginReceive : unit -> IAsyncResult

Public Function BeginReceive () As IAsyncResult

Retours

IAsyncResult qui identifie la requête asynchrone publiée.

Exceptions

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ée « myQueue ». La Main fonction commence l’opération asynchrone qui est 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 les requêtes asynchrones. L’appel à BeginReceive utilise dans AsyncWaitHandle sa valeur de retour. 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 ; le MessageQueue est averti, par le déclenchement de l’événement ReceiveCompleted , lorsqu’un message arrive dans la file d’attente. le MessageQueue 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é que BeginReceive est asynchrone, vous pouvez l’appeler pour recevoir un message de la file d’attente sans bloquer le thread d’exécution actuel. Pour recevoir un message de manière synchrone, utilisez la Receive méthode .

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

Le IAsyncResult qui BeginReceive retourne identifie l’opération asynchrone que la méthode a démarrée. 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 n’est EndReceive(IAsyncResult) 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 la fin de toutes les opérations ou d’une opération. Dans ce cas, vous utilisez la AsyncWaitHandle propriété de pour IAsyncResult identifier l’opération terminée.

Si CanRead a la valeur false, l’événement d’achèvement est déclenché, mais une exception est levée lors de l’appel EndReceive(IAsyncResult)de .

N’utilisez pas l’appel BeginReceive asynchrone avec des transactions. Si vous souhaitez effectuer une opération asynchrone transactionnelle, appelez BeginPeek, puis 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.

Voir aussi

• ReceiveCompleted
• BeginPeek()
• Receive()
• Peek()

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

Retours

IAsyncResult qui identifie la requête asynchrone publiée.

Exceptions

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, MyReceiveCompletedet l’attache au délégué du ReceiveCompleted gestionnaire d’événements. L’exemple de code envoie un message à une file d’attente de messages locale, puis appelle BeginReceive(TimeSpan), en passant une valeur de délai d’attente de dix secondes. Lorsqu’un ReceiveCompleted événement est déclenché, le gestionnaire d’événements 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 ; le MessageQueue est averti, par le déclenchement de l’événement ReceiveCompleted , lorsqu’un message arrive dans la file d’attente. Le MessageQueue peut ensuite accéder au message en appelant EndReceive(IAsyncResult) ou en récupérant le résultat à l’aide de 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é que BeginReceive est asynchrone, vous pouvez l’appeler pour recevoir un message de la file d’attente sans bloquer le thread d’exécution actuel. Pour recevoir un message de manière synchrone, utilisez la Receive méthode .

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

Si CanRead a la valeur false, l’événement d’achèvement est déclenché, mais une exception est levée lors de l’appel EndReceive(IAsyncResult)de .

Le IAsyncResult qui BeginReceive retourne identifie l’opération asynchrone que la méthode a démarrée. 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 n’est EndReceive(IAsyncResult) 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 la fin de toutes les opérations ou d’une opération. Dans ce cas, vous utilisez la AsyncWaitHandle propriété de pour IAsyncResult 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 suivant à EndReceive(IAsyncResult) lève une exception.

N’utilisez pas l’appel BeginReceive asynchrone avec des transactions. Si vous souhaitez effectuer une opération asynchrone transactionnelle, appelez BeginPeek, puis 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.

Voir aussi

• ReceiveCompleted
• BeginPeek()
• Receive()
• Peek()
• TimeSpan

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

Retours

IAsyncResult qui identifie la requête asynchrone publiée.

Exceptions

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, MyReceiveCompletedet l’attache au délégué du ReceiveCompleted gestionnaire d’événements. L’exemple de code envoie un message à une file d’attente de messages locale, puis appelle BeginReceive(TimeSpan, Object), en passant une valeur de délai d’attente de dix secondes et un entier unique qui identifie ce message particulier. Lorsqu’un ReceiveCompleted événement est déclenché, le gestionnaire d’événements reçoit le message et écrit le corps du message et l’identificateur de message entier dans 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é de qui IAsyncResult est associée à l’opération.

Pour utiliser BeginReceive, créez un gestionnaire d’événements qui traite les résultats de l’opération asynchrone et associez-le à votre délégué d’événement. BeginReceive lance une opération de réception asynchrone ; le MessageQueue est averti, par le biais de la déclenchement de l’événement ReceiveCompleted , lorsqu’un message arrive dans la file d’attente. MessageQueue le peut ensuite accéder au message en appelant EndReceive(IAsyncResult) ou en récupérant le résultat à l’aide de 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 BeginReceive asynchrone, vous pouvez l’appeler pour recevoir un message de la file d’attente sans bloquer le thread d’exécution actuel. Pour recevoir de manière synchrone un message, utilisez la Receive méthode .

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

BeginReceive Qui IAsyncResult retourne identifie l’opération asynchrone que la méthode a démarrée. Vous pouvez l’utiliser IAsyncResult pendant toute la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle n’est EndReceive(IAsyncResult) 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 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 suivant à EndReceive(IAsyncResult) lève une exception.

L’objet state associe des 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 à l’aide d’un objet d’état distinct que vous définissez.

Vous pouvez également utiliser l’objet state pour transmettre des informations entre des 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 renvoyé avec les informations de l’événement.

N’utilisez pas l’appel BeginReceive asynchrone avec des transactions. Si vous souhaitez effectuer une opération asynchrone transactionnelle, appelez BeginPeek, puis 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.

Voir aussi

• ReceiveCompleted
• BeginPeek()
• Receive()
• Peek()
• TimeSpan

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

Retours

IAsyncResult qui identifie la requête asynchrone publiée.

Exceptions

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 locale, 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 qui identifie le gestionnaire d’événementsAsyncCallback, MyReceiveCompleted. Lorsqu’un ReceiveCompleted événement est déclenché, le gestionnaire d’événements reçoit le message et écrit le corps du message et l’identificateur de message entier dans 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 s’appuient BeginReceive 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 associez-le à votre délégué d’événement. BeginReceive lance une opération de réception asynchrone ; le MessageQueue est averti, par le biais de la déclenchement de l’événement ReceiveCompleted , lorsqu’un message arrive dans la file d’attente. MessageQueue le peut ensuite accéder au message en appelant EndReceive(IAsyncResult) ou en récupérant le résultat à l’aide de 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 BeginReceive asynchrone, vous pouvez l’appeler pour recevoir un message de la file d’attente sans bloquer le thread d’exécution actuel. Pour recevoir de manière synchrone un message, utilisez la Receive méthode .

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

BeginReceive Qui IAsyncResult retourne identifie l’opération asynchrone que la méthode a démarrée. Vous pouvez l’utiliser IAsyncResult pendant toute la durée de vie de l’opération, bien que vous ne l’utilisiez généralement pas tant qu’elle n’est EndReceive(IAsyncResult) 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 IAsyncResult pour identifier l’opération terminée.

L’objet state associe des 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 à l’aide d’un objet d’état distinct que vous définissez.

Vous pouvez également utiliser l’objet state pour transmettre des informations entre des 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 renvoyé avec les informations de l’événement.

N’utilisez pas l’appel BeginReceive asynchrone avec des transactions. Si vous souhaitez effectuer une opération asynchrone transactionnelle, appelez BeginPeek, puis 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.

Voir aussi

• ReceiveCompleted
• BeginPeek()
• Receive()
• Peek()
• AsyncCallback
• TimeSpan

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

Retours

IAsyncResult qui identifie la requête asynchrone publiée.

Exceptions

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 s’appuient BeginReceive 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 ; le MessageQueue est averti, par le déclenchement de l’événement ReceiveCompleted , lorsqu’un message arrive dans la file d’attente. Le MessageQueue peut ensuite accéder au message en appelant EndReceive(IAsyncResult) ou en récupérant le résultat à l’aide de 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é que BeginReceive est asynchrone, vous pouvez l’appeler pour recevoir un message de la file d’attente sans bloquer le thread d’exécution actuel. Pour recevoir un message de manière synchrone, utilisez la Receive méthode .

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

Le IAsyncResult qui BeginReceive retourne identifie l’opération asynchrone que la méthode a démarrée. 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 n’est EndReceive(IAsyncResult) 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 la fin de toutes les opérations ou d’une opération. Dans ce cas, utilisez la AsyncWaitHandle propriété de pour IAsyncResult identifier l’opération terminée.

L’objet state 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 via un objet d’état distinct que vous définissez.

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

N’utilisez pas l’appel BeginReceive asynchrone avec des transactions. Si vous souhaitez effectuer une opération asynchrone transactionnelle, appelez BeginPeek, puis 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.

Voir aussi

• Cursor
• ReceiveCompleted
• BeginPeek()
• Receive()
• Peek()
• AsyncCallback
• TimeSpan