ReceiveCompletedEventArgs Classe

Definizione

Fornisce dati per l'evento ReceiveCompleted.Provides data for the ReceiveCompleted event. Quando l'operazione di ricezione asincrona chiama un gestore eventi, un'istanza di questa classe viene passata al gestore.When your asynchronous receive operation calls an event handler, an instance of this class is passed to the handler.

public ref class ReceiveCompletedEventArgs : EventArgs
public class ReceiveCompletedEventArgs : EventArgs
type ReceiveCompletedEventArgs = class
    inherit EventArgs
Public Class ReceiveCompletedEventArgs
Inherits EventArgs
Ereditarietà
ReceiveCompletedEventArgs

Esempi

L'esempio di codice seguente crea un gestore eventi per ReceiveCompleted l'evento e lo associa al delegato dell'evento ReceiveCompletedEventHandlerusando.The following code example creates an event handler for the ReceiveCompleted event and associates it with the event delegate by using the ReceiveCompletedEventHandler. Il gestore eventi, MyReceiveCompleted, riceve un messaggio da una coda e ne scrive il corpo sullo schermo.The event handler, MyReceiveCompleted, receives a message from a queue and writes its body to the screen.

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:

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

      // End the asynchronous Receive operation.
      Message^ m = mq->EndReceive( asyncResult->AsyncResult );

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

      // Restart the asynchronous Receive operation.
      mq->BeginReceive();
      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();

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

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

        //**************************************************
        // Provides an entry point into the application.
        //		 
        // This example 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();
            
            // Do other work on the current thread.

            return;
        }


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

            // End the asynchronous Receive operation.
            Message m = mq.EndReceive(asyncResult.AsyncResult);

            // Display message information on the screen.
            Console.WriteLine("Message: " + (string)m.Body);

            // Restart the asynchronous Receive operation.
            mq.BeginReceive();
            
            return; 
        }
    }
}
Imports System.Messaging

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

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

            ' 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)

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

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

            ' Display message information on the screen.
            Console.WriteLine(("Message: " + CStr(m.Body)))

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

            Return

        End Sub

End Class

Commenti

Quando si utilizza la notifica degli eventi per ricevere messaggi in modo asincrono dalla coda, è necessario creare un metodo che gestisce l'elaborazione del messaggio.When you use event notification to receive messages asynchronously from the queue, you must create a method that handles your message processing. Il codice deve chiamare BeginReceive per iniziare l'elaborazione asincrona.Your code must call BeginReceive to begin the asynchronous processing. Quando viene ricevuto un messaggio, l'applicazione riceve una notifica tramite ReceiveCompleted l'evento.When a message is received, your application is notified through the ReceiveCompleted event. Un'istanza di ReceiveCompletedEventArgs viene passata al delegato dell'evento che chiama il gestore eventi.An instance of ReceiveCompletedEventArgs is passed into the event delegate that calls your event handler. I dati associati ReceiveCompleted all'evento sono contenuti nel AsyncResult parametro del delegato.The data associated with the ReceiveCompleted event is contained in the delegate's AsyncResult parameter.

Esistono due modi per fornire la notifica del completamento dell'evento: la notifica degli eventi e i callback.There are two ways to provide notification of event completion: event notification and callbacks. ReceiveCompletedEventArgsviene utilizzato solo con la notifica degli eventi.ReceiveCompletedEventArgs is used only with event notification. Per informazioni sul confronto tra callback e notifica degli eventi, vedere "eventi e Callback "su MSDN.For information comparing callbacks and event notification, see "Events vs. Callbacks" on MSDN.

ReceiveCompletedEventArgsconsente di accedere al messaggio che ha avviato la fine dell'operazione di ricezione asincrona tramite il Message membro.ReceiveCompletedEventArgs provides access to the message that initiated the end of the asynchronous receive operation, through the Message member. Si tratta di un accesso alternativo al messaggio e si comporta in modo molto simile a una chiamata a MessageQueue.EndReceive.This is an alternate access to the message, and behaves much the same as a call to MessageQueue.EndReceive.

Proprietà

AsyncResult

Ottiene o imposta i risultati dell'operazione asincrona richiesta.Gets or sets the result of the asynchronous operation requested.

Message

Ottiene il messaggio associato all'operazione di ricezione asincrona.Gets the message associated with the asynchronous receive operation.

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Si applica a

Vedi anche