MessageQueue.BeginReceive Metodo

Definizione

Avvia un'operazione di ricezione asincrona, indicando ad Accodamento messaggi di avviare la ricezione di un messaggio e inviare una notifica al gestore eventi al termine dell'operazione.Initiates an asynchronous receive operation by telling Message Queuing to begin receiving a message and notify the event handler when finished.

Overload

BeginReceive()

Avvia un'operazione di ricezione asincrona per la quale non è stato specificato alcun timeout. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda.Initiates an asynchronous receive operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginReceive(TimeSpan)

Avvia un'operazione di ricezione asincrona per la quale è stato specificato un periodo di timeout. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.Initiates an asynchronous receive operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object)

Avvia un'operazione di ricezione asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object, AsyncCallback)

Avvia un'operazione di ricezione asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Avvia un'operazione di ricezione asincrona che presenta il timeout specificato e che utilizza il cursore specificato, l'azione di lettura specificata e l'oggetto di stato specificato.Initiates an asynchronous receive operation that has a specified time-out and uses a specified cursor and a specified state object. L'oggetto di stato fornisce informazioni associate per l'intera durata dell'operazione.The state object provides associated information throughout the lifetime of the operation. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive()

Avvia un'operazione di ricezione asincrona per la quale non è stato specificato alcun timeout. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda.Initiates an asynchronous receive operation that has no time-out. The operation is not complete until a message becomes available in the queue.

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

Restituisce

IAsyncResult che identifica la richiesta asincrona inviata.The IAsyncResult that identifies the posted asynchronous request.

Eccezioni

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

Nell'esempio di codice seguente vengono concatenate richieste asincrone.The following code example chains asynchronous requests. Si presuppone che nel computer locale sia presente una coda denominata "coda".It assumes there is a queue on the local computer called "myQueue". La Main funzione avvia l'operazione asincrona gestita MyReceiveCompleted dalla routine.The Main function begins the asynchronous operation that is handled by the MyReceiveCompleted routine. MyReceiveCompletedelabora il messaggio corrente e avvia una nuova operazione di ricezione asincrona.MyReceiveCompleted processes the current message and begins a new asynchronous receive operation.

#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

Nell'esempio di codice seguente vengono accodate richieste asincrone.The following code example queues asynchronous requests. La chiamata a BeginReceive AsyncWaitHandle utilizza nel valore restituito.The call to BeginReceive uses the AsyncWaitHandle in its return value. La Main routine attende il completamento di tutte le operazioni asincrone prima di uscire.The Main routine waits for all asynchronous operations to be completed before exiting.

#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

Commenti

Nell'elaborazione asincrona si utilizza BeginReceive per generare l' ReceiveCompleted evento quando un messaggio è stato rimosso dalla coda.In asynchronous processing, you use BeginReceive to raise the ReceiveCompleted event when a message has been removed from the queue.

ReceiveCompletedviene generato anche se un messaggio esiste già nella coda.ReceiveCompleted is also raised if a message already exists in the queue.

Per utilizzare BeginReceive, creare un gestore eventi che elabora i risultati dell'operazione asincrona e li associa al delegato dell'evento.To use BeginReceive, create an event handler that processes the results of the asynchronous operation and associate it with your event delegate. BeginReceiveavvia un'operazione di ricezione asincrona. viene notificato, tramite la generazione ReceiveCompleted dell'evento, quando un messaggio arriva nella coda. MessageQueueBeginReceive initiates an asynchronous receive operation; the MessageQueue is notified, through the raising of the ReceiveCompleted event, when a message arrives in the queue. Può quindi accedere al messaggio EndReceive(IAsyncResult)chiamando. MessageQueueThe MessageQueue can then access the message by calling EndReceive(IAsyncResult).

Il BeginReceive metodo restituisce immediatamente un risultato, ma l'operazione asincrona non viene completata fino a quando non viene chiamato il gestore eventi.The BeginReceive method returns immediately, but the asynchronous operation is not completed until the event handler is called.

Poiché BeginReceive è asincrono, è possibile chiamarlo per ricevere un messaggio dalla coda senza bloccare il thread di esecuzione corrente.Because BeginReceive is asynchronous, you can call it to receive a message from the queue without blocking the current thread of execution. Per ricevere un messaggio in modo sincrono, Receive usare il metodo.To synchronously receive a message, use the Receive method.

Al termine di un'operazione asincrona, è possibile chiamare BeginPeek o BeginReceive di nuovo nel gestore eventi per ricevere le notifiche.Once an asynchronous operation completes, you can call BeginPeek or BeginReceive again in the event handler to keep receiving notifications.

L' IAsyncResult oggetto BeginReceive che restituisce identifica l'operazione asincrona avviata dal metodo.The IAsyncResult that BeginReceive returns identifies the asynchronous operation that the method started. È possibile usarlo IAsyncResult per tutta la durata dell'operazione, sebbene in genere non venga usato fino a EndReceive(IAsyncResult) quando non viene chiamato il metodo.You can use this IAsyncResult throughout the lifetime of the operation, although you generally do not use it until EndReceive(IAsyncResult) is called. Tuttavia, se si avviano diverse operazioni asincrone, è possibile inserire IAsyncResult i valori in una matrice e specificare se attendere il completamento di tutte le operazioni o di qualsiasi operazione.However, if you start several asynchronous operations, you can place their IAsyncResult values in an array and specify whether to wait for all operations or any operation to complete. In questo caso, è possibile usare AsyncWaitHandle la proprietà IAsyncResult di per identificare l'operazione completata.In this case, you use the AsyncWaitHandle property of the IAsyncResult to identify the completed operation.

Se CanRead EndReceive(IAsyncResult)è false, viene generato l'evento di completamento, ma viene generata un'eccezione durante la chiamata a.If CanRead is false, the completion event is raised, but an exception will be thrown when calling EndReceive(IAsyncResult).

Non utilizzare la chiamata BeginReceive asincrona con le transazioni.Do not use the asynchronous call BeginReceive with transactions. Se si desidera eseguire un'operazione asincrona transazionale, chiamare BeginPeeke inserire la transazione e il metodo (sincrono) Receive nel gestore eventi creato per l'operazione di visualizzazione.If you want to perform a transactional asynchronous operation, call BeginPeek, and put the transaction and the (synchronous) Receive method within the event handler you create for the peek operation. Il gestore eventi potrebbe contenere funzionalità come illustrato nel codice seguente C# .Your event handler might contain functionality as shown in the following C# code.

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

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

BeginReceive(TimeSpan)

Avvia un'operazione di ricezione asincrona per la quale è stato specificato un periodo di timeout. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.Initiates an asynchronous receive operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica il tempo di attesa necessario affinché un messaggio diventi disponibile.A TimeSpan that indicates the interval of time to wait for a message to become available.

Restituisce

IAsyncResult che identifica la richiesta asincrona inviata.The IAsyncResult that identifies the posted asynchronous request.

Eccezioni

Il valore specificato per il parametro timeout non è valido, probabilmente perché rappresenta un numero negativo.The value specified for the timeout parameter is not valid, possibly because it represents a negative number.

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

Nell'esempio di codice seguente viene creata un'operazione di ricezione asincrona.The following code example creates an asynchronous receive operation. Nell'esempio di codice viene creato un gestore MyReceiveCompletedeventi,, che viene collegato al ReceiveCompleted delegato del gestore eventi.The code example creates an event handler, MyReceiveCompleted, and attaches it to the ReceiveCompleted event handler delegate. Nell'esempio di codice viene inviato un messaggio a una coda di messaggi locale BeginReceive(TimeSpan), quindi viene chiamato il passaggio di un valore di timeout di dieci secondi.The code example sends a message to a local message queue, then calls BeginReceive(TimeSpan), passing in a time-out value of ten seconds. Quando viene ReceiveCompleted generato un evento, il gestore eventi riceve il messaggio e scrive il corpo del messaggio sullo schermo.When a ReceiveCompleted event is raised, the event handler receives the message and writes the message body to the screen.

#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);
    }
}

Commenti

Nell'elaborazione asincrona si utilizza BeginReceive per generare l' ReceiveCompleted evento quando un messaggio diventa disponibile nella coda o quando l'intervallo di tempo specificato è scaduto.In asynchronous processing, you use BeginReceive to raise the ReceiveCompleted event when a message becomes available in the queue or when the specified interval of time has expired.

ReceiveCompletedviene generato anche se un messaggio esiste già nella coda.ReceiveCompleted is also raised if a message already exists in the queue.

Per utilizzare BeginReceive, creare un gestore eventi che elabora i risultati dell'operazione asincrona e li associa al delegato dell'evento.To use BeginReceive, create an event handler that processes the results of the asynchronous operation and associate it with your event delegate. BeginReceiveavvia un'operazione di ricezione asincrona. viene notificato, tramite la generazione ReceiveCompleted dell'evento, quando un messaggio arriva nella coda. MessageQueueBeginReceive initiates an asynchronous receive operation; the MessageQueue is notified, through the raising of the ReceiveCompleted event, when a message arrives in the queue. Può quindi accedere al messaggio EndReceive(IAsyncResult) chiamando o recuperando il risultato utilizzando ReceiveCompletedEventArgs. MessageQueueThe MessageQueue can then access the message by calling EndReceive(IAsyncResult) or retrieving the result using the ReceiveCompletedEventArgs.

Il BeginReceive metodo restituisce immediatamente un risultato, ma l'operazione asincrona non viene completata fino a quando non viene chiamato il gestore eventi.The BeginReceive method returns immediately, but the asynchronous operation is not completed until the event handler is called.

Poiché BeginReceive è asincrono, è possibile chiamarlo per ricevere un messaggio dalla coda senza bloccare il thread di esecuzione corrente.Because BeginReceive is asynchronous, you can call it to receive a message from the queue without blocking the current thread of execution. Per ricevere un messaggio in modo sincrono, Receive usare il metodo.To synchronously receive a message, use the Receive method.

Al termine di un'operazione asincrona, è possibile chiamare BeginPeek o BeginReceive di nuovo nel gestore eventi per ricevere le notifiche.Once an asynchronous operation completes, you can call BeginPeek or BeginReceive again in the event handler to keep receiving notifications.

Se CanRead EndReceive(IAsyncResult)è false, viene generato l'evento di completamento, ma viene generata un'eccezione durante la chiamata a.If CanRead is false, the completion event is raised, but an exception will be thrown when calling EndReceive(IAsyncResult).

L' IAsyncResult oggetto BeginReceive che restituisce identifica l'operazione asincrona avviata dal metodo.The IAsyncResult that BeginReceive returns identifies the asynchronous operation that the method started. È possibile usarlo IAsyncResult per tutta la durata dell'operazione, sebbene in genere non venga usato fino a EndReceive(IAsyncResult) quando non viene chiamato il metodo.You can use this IAsyncResult throughout the lifetime of the operation, although you generally do not use it until EndReceive(IAsyncResult) is called. Tuttavia, se si avviano diverse operazioni asincrone, è possibile inserire IAsyncResult i valori in una matrice e specificare se attendere il completamento di tutte le operazioni o di qualsiasi operazione.However, if you start several asynchronous operations, you can place their IAsyncResult values in an array and specify whether to wait for all operations or any operation to complete. In questo caso, è possibile usare AsyncWaitHandle la proprietà IAsyncResult di per identificare l'operazione completata.In this case, you use the AsyncWaitHandle property of the IAsyncResult to identify the completed operation.

Questo overload specifica un timeout. Se l'intervallo specificato dal timeout parametro scade, questo componente genera l' ReceiveCompleted evento.This overload specifies a time-out. If the interval specified by the timeout parameter expires, this component raises the ReceiveCompleted event. Poiché non esiste alcun messaggio, una chiamata successiva EndReceive(IAsyncResult) a genererà un'eccezione.Because no message exists, a subsequent call to EndReceive(IAsyncResult) will throw an exception.

Non utilizzare la chiamata BeginReceive asincrona con le transazioni.Do not use the asynchronous call BeginReceive with transactions. Se si desidera eseguire un'operazione asincrona transazionale, chiamare BeginPeeke inserire la transazione e il metodo (sincrono) Receive nel gestore eventi creato per l'operazione di visualizzazione.If you want to perform a transactional asynchronous operation, call BeginPeek, and put the transaction and the (synchronous) Receive method within the event handler you create for the peek operation. Il gestore eventi potrebbe contenere funzionalità come illustrato nel codice seguente C# .Your event handler might contain functionality as shown in the following C# code.

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

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

BeginReceive(TimeSpan, Object)

Avvia un'operazione di ricezione asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica il tempo di attesa necessario affinché un messaggio diventi disponibile.A TimeSpan that indicates the interval of time to wait for a message to become available.

stateObject
Object

Oggetto di stato, specificato dall'applicazione, che contiene le informazioni associate all'operazione asincrona.A state object, specified by the application, that contains information associated with the asynchronous operation.

Restituisce

IAsyncResult che identifica la richiesta asincrona inviata.The IAsyncResult that identifies the posted asynchronous request.

Eccezioni

Il valore specificato per il parametro timeout non è valido.The value specified for the timeout parameter is not valid.

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

Nell'esempio di codice seguente viene creata un'operazione di ricezione asincrona.The following code example creates an asynchronous receive operation. Nell'esempio di codice viene creato un gestore MyReceiveCompletedeventi,, che viene collegato al ReceiveCompleted delegato del gestore eventi.The code example creates an event handler, MyReceiveCompleted, and attaches it to the ReceiveCompleted event handler delegate. L'esempio di codice invia un messaggio a una coda di messaggi locale, BeginReceive(TimeSpan, Object)quindi chiama, passando un valore di timeout di dieci secondi e un intero univoco che identifica quel particolare messaggio.The code example sends a message to a local message queue, then calls BeginReceive(TimeSpan, Object), passing in a time-out value of ten seconds and a unique integer that identifies that particular message. Quando viene ReceiveCompleted generato un evento, il gestore eventi riceve il messaggio e scrive il corpo del messaggio e l'identificatore del messaggio Integer sullo schermo.When a ReceiveCompleted event is raised, the event handler receives the message and writes the message body and the integer message identifier to the screen.

#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);
    }
}

Commenti

Nell'elaborazione asincrona si utilizza BeginReceive per generare l' ReceiveCompleted evento quando un messaggio diventa disponibile nella coda o quando l'intervallo di tempo specificato è scaduto.In asynchronous processing, you use BeginReceive to raise the ReceiveCompleted event when a message becomes available in the queue or when the specified interval of time has expired.

ReceiveCompletedviene generato anche se un messaggio esiste già nella coda.ReceiveCompleted is also raised if a message already exists in the queue.

Utilizzare questo overload per associare le informazioni all'operazione che verrà mantenuta per tutta la durata dell'operazione.Use this overload to associate information with the operation that will be preserved throughout the operation's lifetime. Il gestore eventi può rilevare queste informazioni esaminando la AsyncState proprietà dell'oggetto IAsyncResult associato all'operazione.The event handler can detect this information by looking at the AsyncState property of the IAsyncResult that is associated with the operation.

Per utilizzare BeginReceive, creare un gestore eventi che elabora i risultati dell'operazione asincrona e li associa al delegato dell'evento.To use BeginReceive, create an event handler that processes the results of the asynchronous operation and associate it with your event delegate. BeginReceiveavvia un'operazione di ricezione asincrona. viene notificato, tramite la generazione ReceiveCompleted dell'evento, quando un messaggio arriva nella coda. MessageQueueBeginReceive initiates an asynchronous receive operation; the MessageQueue is notified, through the raising of the ReceiveCompleted event, when a message arrives in the queue. Può quindi accedere al messaggio EndReceive(IAsyncResult) chiamando o recuperando il risultato utilizzando ReceiveCompletedEventArgs. MessageQueueThe MessageQueue can then access the message by calling EndReceive(IAsyncResult) or retrieving the result using the ReceiveCompletedEventArgs.

Il BeginReceive metodo restituisce immediatamente un risultato, ma l'operazione asincrona non viene completata fino a quando non viene chiamato il gestore eventi.The BeginReceive method returns immediately, but the asynchronous operation is not completed until the event handler is called.

Poiché BeginReceive è asincrono, è possibile chiamarlo per ricevere un messaggio dalla coda senza bloccare il thread di esecuzione corrente.Because BeginReceive is asynchronous, you can call it to receive a message from the queue without blocking the current thread of execution. Per ricevere un messaggio in modo sincrono, Receive usare il metodo.To synchronously receive a message, use the Receive method.

Al termine di un'operazione asincrona, è possibile chiamare BeginPeek o BeginReceive di nuovo nel gestore eventi per ricevere le notifiche.Once an asynchronous operation completes, you can call BeginPeek or BeginReceive again in the event handler to keep receiving notifications.

L' IAsyncResult oggetto BeginReceive che restituisce identifica l'operazione asincrona avviata dal metodo.The IAsyncResult that BeginReceive returns identifies the asynchronous operation that the method started. È possibile usarlo IAsyncResult per tutta la durata dell'operazione, sebbene in genere non venga usato fino a EndReceive(IAsyncResult) quando non viene chiamato il metodo.You can use this IAsyncResult throughout the lifetime of the operation, although you generally do not use it until EndReceive(IAsyncResult) is called. Tuttavia, se si avviano diverse operazioni asincrone, è possibile inserire IAsyncResult i valori in una matrice e specificare se attendere il completamento di tutte le operazioni o di qualsiasi operazione.However, if you start several asynchronous operations, you can place their IAsyncResult values in an array and specify whether to wait for all operations or any operation to complete. In questo caso, è possibile usare AsyncWaitHandle la proprietà IAsyncResult di per identificare l'operazione completata.In this case, you use the AsyncWaitHandle property of the IAsyncResult to identify the completed operation.

Questo overload specifica un timeout e un oggetto di stato.This overload specifies a time-out and a state object. Se l'intervallo specificato dal timeout parametro scade, questo componente genera l' ReceiveCompleted evento.If the interval specified by the timeout parameter expires, this component raises the ReceiveCompleted event. Poiché non esiste alcun messaggio, una chiamata successiva EndReceive(IAsyncResult) a genererà un'eccezione.Because no message exists, a subsequent call to EndReceive(IAsyncResult) will throw an exception.

L'oggetto stato associa le informazioni di stato all'operazione.The state object associates state information with the operation. Se, ad esempio, si BeginReceive chiama più volte per avviare più operazioni, è possibile identificare ogni operazione tramite un oggetto di stato separato definito dall'utente.For example, if you call BeginReceive multiple times to initiate multiple operations, you can identify each operation through a separate state object that you define.

È anche possibile usare l'oggetto stato per passare informazioni tra thread di processo.You can also use the state object to pass information across process threads. Se un thread viene avviato ma il callback si trova in un thread diverso in uno scenario asincrono, viene effettuato il marshalling dell'oggetto di stato e viene passato di nuovo insieme alle informazioni dell'evento.If a thread is started but the callback is on a different thread in an asynchronous scenario, the state object is marshaled and passed back along with information from the event.

Non utilizzare la chiamata BeginReceive asincrona con le transazioni.Do not use the asynchronous call BeginReceive with transactions. Se si desidera eseguire un'operazione asincrona transazionale, chiamare BeginPeeke inserire la transazione e il metodo (sincrono) Receive nel gestore eventi creato per l'operazione di visualizzazione.If you want to perform a transactional asynchronous operation, call BeginPeek, and put the transaction and the (synchronous) Receive method within the event handler you create for the peek operation. Il gestore eventi potrebbe contenere funzionalità come illustrato nel codice seguente C# .Your event handler might contain functionality as shown in the following C# code.

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

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

BeginReceive(TimeSpan, Object, AsyncCallback)

Avvia un'operazione di ricezione asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica il tempo di attesa necessario affinché un messaggio diventi disponibile.A TimeSpan that indicates the interval of time to wait for a message to become available.

stateObject
Object

Oggetto di stato, specificato dall'applicazione, che contiene le informazioni associate all'operazione asincrona.A state object, specified by the application, that contains information associated with the asynchronous operation.

callback
AsyncCallback

AsyncCallback che riceverà la notifica del completamento dell'operazione asincrona.The AsyncCallback that will receive the notification of the asynchronous operation completion.

Restituisce

IAsyncResult che identifica la richiesta asincrona inviata.The IAsyncResult that identifies the posted asynchronous request.

Eccezioni

Il valore specificato per il parametro timeout non è valido.The value specified for the timeout parameter is not valid.

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

Nell'esempio di codice seguente viene creata un'operazione di ricezione asincrona.The following code example creates an asynchronous receive operation. Nell'esempio di codice viene inviato un messaggio a una coda di messaggi locale BeginReceive(TimeSpan, Object, AsyncCallback), quindi viene chiamato il passaggio: un valore di timeout di dieci secondi, un numero intero univoco che identifica il messaggio specifico e una nuova AsyncCallback istanza di che identifica il gestore eventiMyReceiveCompleted.The code example sends a message to a local message queue, then calls BeginReceive(TimeSpan, Object, AsyncCallback), passing in: a time-out value of ten seconds; a unique integer that identifies that particular message; and a new instance of AsyncCallback that identifies the event handler, MyReceiveCompleted. Quando viene ReceiveCompleted generato un evento, il gestore eventi riceve il messaggio e scrive il corpo del messaggio e l'identificatore del messaggio Integer sullo schermo.When a ReceiveCompleted event is raised, the event handler receives the message and writes the message body and the integer message identifier to the screen.

#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);
    }
}

Commenti

Quando si utilizza questo overload, il callback specificato nel parametro di callback viene richiamato direttamente quando un messaggio diventa disponibile nella coda o quando l'intervallo di tempo specificato è scaduto; l' ReceiveCompleted evento non viene generato.When you use this overload, the callback specified in the callback parameter is invoked directly when a message becomes available in the queue or when the specified interval of time has expired; the ReceiveCompleted event is not raised. Gli altri overload di BeginReceive si basano su questo componente per generare l' ReceiveCompleted evento.The other overloads of BeginReceive rely on this component to raise the ReceiveCompleted event.

ReceiveCompletedviene generato anche se un messaggio esiste già nella coda.ReceiveCompleted is also raised if a message already exists in the queue.

Per utilizzare BeginReceive, creare un gestore eventi che elabora i risultati dell'operazione asincrona e li associa al delegato dell'evento.To use BeginReceive, create an event handler that processes the results of the asynchronous operation and associate it with your event delegate. BeginReceiveavvia un'operazione di ricezione asincrona. viene notificato, tramite la generazione ReceiveCompleted dell'evento, quando un messaggio arriva nella coda. MessageQueueBeginReceive initiates an asynchronous receive operation; the MessageQueue is notified, through the raising of the ReceiveCompleted event, when a message arrives in the queue. Può quindi accedere al messaggio EndReceive(IAsyncResult) chiamando o recuperando il risultato utilizzando ReceiveCompletedEventArgs. MessageQueueThe MessageQueue can then access the message by calling EndReceive(IAsyncResult) or retrieving the result using the ReceiveCompletedEventArgs.

Il BeginReceive metodo restituisce immediatamente un risultato, ma l'operazione asincrona non viene completata fino a quando non viene chiamato il gestore eventi.The BeginReceive method returns immediately, but the asynchronous operation is not completed until the event handler is called.

Poiché BeginReceive è asincrono, è possibile chiamarlo per ricevere un messaggio dalla coda senza bloccare il thread di esecuzione corrente.Because BeginReceive is asynchronous, you can call it to receive a message from the queue without blocking the current thread of execution. Per ricevere un messaggio in modo sincrono, Receive usare il metodo.To synchronously receive a message, use the Receive method.

Al termine di un'operazione asincrona, è possibile chiamare BeginPeek o BeginReceive di nuovo nel gestore eventi per ricevere le notifiche.Once an asynchronous operation completes, you can call BeginPeek or BeginReceive again in the event handler to keep receiving notifications.

L' IAsyncResult oggetto BeginReceive che restituisce identifica l'operazione asincrona avviata dal metodo.The IAsyncResult that BeginReceive returns identifies the asynchronous operation that the method started. È possibile usarlo IAsyncResult per tutta la durata dell'operazione, sebbene in genere non venga usato fino a EndReceive(IAsyncResult) quando non viene chiamato il metodo.You can use this IAsyncResult throughout the lifetime of the operation, although you generally do not use it until EndReceive(IAsyncResult) is called. Tuttavia, se si avviano diverse operazioni asincrone, è possibile inserire IAsyncResult i valori in una matrice e specificare se attendere il completamento di tutte le operazioni o di qualsiasi operazione.However, if you start several asynchronous operations, you can place their IAsyncResult values in an array and specify whether to wait for all operations or any operation to complete. In questo caso, è possibile usare AsyncWaitHandle la proprietà IAsyncResult di per identificare l'operazione completata.In this case, you use the AsyncWaitHandle property of the IAsyncResult to identify the completed operation.

L'oggetto stato associa le informazioni di stato all'operazione.The state object associates state information with the operation. Se, ad esempio, si BeginReceive chiama più volte per avviare più operazioni, è possibile identificare ogni operazione tramite un oggetto di stato separato definito dall'utente.For example, if you call BeginReceive multiple times to initiate multiple operations, you can identify each operation through a separate state object that you define.

È anche possibile usare l'oggetto stato per passare informazioni tra thread di processo.You can also use the state object to pass information across process threads. Se un thread viene avviato ma il callback si trova in un thread diverso in uno scenario asincrono, viene effettuato il marshalling dell'oggetto di stato e viene passato di nuovo insieme alle informazioni dell'evento.If a thread is started but the callback is on a different thread in an asynchronous scenario, the state object is marshaled and passed back along with information from the event.

Non utilizzare la chiamata BeginReceive asincrona con le transazioni.Do not use the asynchronous call BeginReceive with transactions. Se si desidera eseguire un'operazione asincrona transazionale, chiamare BeginPeeke inserire la transazione e il metodo (sincrono) Receive nel gestore eventi creato per l'operazione di visualizzazione.If you want to perform a transactional asynchronous operation, call BeginPeek, and put the transaction and the (synchronous) Receive method within the event handler you create for the peek operation. Il gestore eventi potrebbe contenere funzionalità come illustrato nel codice seguente C# .Your event handler might contain functionality as shown in the following C# code.

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

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Avvia un'operazione di ricezione asincrona che presenta il timeout specificato e che utilizza il cursore specificato, l'azione di lettura specificata e l'oggetto di stato specificato.Initiates an asynchronous receive operation that has a specified time-out and uses a specified cursor and a specified state object. L'oggetto di stato fornisce informazioni associate per l'intera durata dell'operazione.The state object provides associated information throughout the lifetime of the operation. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica il tempo di attesa necessario affinché un messaggio diventi disponibile.A TimeSpan that indicates the interval of time to wait for a message to become available.

cursor
Cursor

Oggetto Cursor che occupa una posizione specifica nella coda messaggi.A Cursor that maintains a specific position in the message queue.

state
Object

Oggetto di stato, specificato dall'applicazione, che contiene le informazioni associate all'operazione asincrona.A state object, specified by the application, that contains information associated with the asynchronous operation.

callback
AsyncCallback

AsyncCallback che riceve la notifica del completamento dell'operazione asincrona.The AsyncCallback that receives the notification of the asynchronous operation completion.

Restituisce

IAsyncResult che identifica la richiesta asincrona inviata.The IAsyncResult that identifies the posted asynchronous request.

Eccezioni

Il valore del parametro cursor è null.The cursor parameter is null.

Il valore specificato per il parametro timeout non è valido.The value specified for the timeout parameter is not valid.

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Commenti

Quando si utilizza questo overload, il callback specificato nel parametro di callback viene richiamato direttamente quando un messaggio diventa disponibile nella coda o quando l'intervallo di tempo specificato è scaduto; l' ReceiveCompleted evento non viene generato.When you use this overload, the callback specified in the callback parameter is invoked directly when a message becomes available in the queue or when the specified interval of time has expired; the ReceiveCompleted event is not raised. Gli altri overload di BeginReceive si basano su questo componente per generare l' ReceiveCompleted evento.The other overloads of BeginReceive rely on this component to raise the ReceiveCompleted event.

ReceiveCompletedviene generato anche se un messaggio esiste già nella coda.ReceiveCompleted is also raised if a message already exists in the queue.

Per utilizzare BeginReceive, creare un gestore eventi che elabora i risultati dell'operazione asincrona e li associa al delegato dell'evento.To use BeginReceive, create an event handler that processes the results of the asynchronous operation and associate it with your event delegate. BeginReceiveavvia un'operazione di ricezione asincrona. viene notificato, tramite la generazione ReceiveCompleted dell'evento, quando un messaggio arriva nella coda. MessageQueueBeginReceive initiates an asynchronous receive operation; the MessageQueue is notified, through the raising of the ReceiveCompleted event, when a message arrives in the queue. Può quindi accedere al messaggio EndReceive(IAsyncResult) chiamando o recuperando il risultato utilizzando ReceiveCompletedEventArgs. MessageQueueThe MessageQueue can then access the message by calling EndReceive(IAsyncResult) or retrieving the result using the ReceiveCompletedEventArgs.

Il BeginReceive metodo restituisce immediatamente un risultato, ma l'operazione asincrona non viene completata fino a quando non viene chiamato il gestore eventi.The BeginReceive method returns immediately, but the asynchronous operation is not completed until the event handler is called.

Poiché BeginReceive è asincrono, è possibile chiamarlo per ricevere un messaggio dalla coda senza bloccare il thread di esecuzione corrente.Because BeginReceive is asynchronous, you can call it to receive a message from the queue without blocking the current thread of execution. Per ricevere un messaggio in modo sincrono, Receive usare il metodo.To synchronously receive a message, use the Receive method.

Al termine di un'operazione asincrona, è possibile chiamare BeginPeek o BeginReceive di nuovo nel gestore eventi per ricevere le notifiche.Once an asynchronous operation completes, you can call BeginPeek or BeginReceive again in the event handler to keep receiving notifications.

L' IAsyncResult oggetto BeginReceive che restituisce identifica l'operazione asincrona avviata dal metodo.The IAsyncResult that BeginReceive returns identifies the asynchronous operation that the method started. È possibile usarlo IAsyncResult per tutta la durata dell'operazione, sebbene in genere non venga usato fino a EndReceive(IAsyncResult) quando non viene chiamato il metodo.You can use this IAsyncResult throughout the lifetime of the operation, although you generally do not use it until EndReceive(IAsyncResult) is called. Tuttavia, se si avviano diverse operazioni asincrone, è possibile inserire IAsyncResult i valori in una matrice e specificare se attendere il completamento di tutte le operazioni o di qualsiasi operazione.However, if you start several asynchronous operations, you can place their IAsyncResult values in an array and specify whether to wait for all operations or any operation to complete. In questo caso, utilizzare la AsyncWaitHandle proprietà IAsyncResult di per identificare l'operazione completata.In this case, use the AsyncWaitHandle property of the IAsyncResult to identify the completed operation.

L'oggetto stato associa le informazioni di stato all'operazione.The state object associates state information with the operation. Se, ad esempio, si BeginReceive chiama più volte per avviare più operazioni, è possibile identificare ogni operazione tramite un oggetto di stato separato definito dall'utente.For example, if you call BeginReceive multiple times to initiate multiple operations, you can identify each operation through a separate state object that you define.

È anche possibile usare l'oggetto stato per passare informazioni tra thread di processo.You can also use the state object to pass information across process threads. Se un thread viene avviato ma il callback si trova in un thread diverso in uno scenario asincrono, viene effettuato il marshalling dell'oggetto di stato e viene passato di nuovo insieme alle informazioni dell'evento.If a thread is started but the callback is on a different thread in an asynchronous scenario, the state object is marshaled and passed back along with information from the event.

Non utilizzare la chiamata BeginReceive asincrona con le transazioni.Do not use the asynchronous call BeginReceive with transactions. Se si desidera eseguire un'operazione asincrona transazionale, chiamare BeginPeeke inserire la transazione e il metodo (sincrono) Receive nel gestore eventi creato per l'operazione di visualizzazione.If you want to perform a transactional asynchronous operation, call BeginPeek, and put the transaction and the (synchronous) Receive method within the event handler you create for the peek operation. Il gestore eventi potrebbe contenere funzionalità come illustrato nel codice seguente C# .Your event handler might contain functionality as shown in the following C# code.

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

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

Si applica a