MessageQueue.EndReceive-Methode

Schließt die angegebene asynchrone Receive-Methode ab.

Namespace: System.Messaging
Assembly: System.Messaging (in system.messaging.dll)

Syntax

'Declaration
Public Function EndReceive ( _
    asyncResult As IAsyncResult _
) As Message
'Usage
Dim instance As MessageQueue
Dim asyncResult As IAsyncResult
Dim returnValue As Message

returnValue = instance.EndReceive(asyncResult)

public Message EndReceive (
    IAsyncResult asyncResult
)

public:
Message^ EndReceive (
    IAsyncResult^ asyncResult
)

public Message EndReceive (
    IAsyncResult asyncResult
)

public function EndReceive (
    asyncResult : IAsyncResult
) : Message

Parameter

• asyncResult
  Ein IAsyncResult, das die abzuschließende asynchrone Receive-Methode bestimmt und über das das Ergebnis abgerufen werden kann.

Rückgabewert

Die dem abgeschlossenen asynchronen Vorgang zugeordnete Message.

Ausnahmen

Ausnahmetyp	Bedingung
ArgumentNullException	Der asyncResult-Parameter ist NULL (Nothing in Visual Basic).
ArgumentException	Die Syntax des asyncResult-Parameters ist ungültig.
MessageQueueException	Fehler beim Zugriff auf eine Message Queuing-Methode.

Hinweise

Wenn das ReceiveCompleted-Ereignis ausgelöst wird, schließt EndReceive den durch den BeginReceive-Aufruf initiierten Vorgang ab. Hierzu empfängt EndReceive die Meldung.

Beim Aufruf von BeginReceive kann ein Timeout angegeben werden. In diesem Fall wird das ReceiveCompleted-Ereignis ausgelöst, wenn der Timeout auftritt, bevor eine Meldung in die Warteschlange eingeht. Die IsCompleted-Eigenschaft des asyncResult-Parameters wird hierbei auf true festgelegt, dem Vorgang ist jedoch keine Meldung zugeordnet. Wenn ein Timeout auftritt, ohne dass eine Meldung in die Warteschlange eingeht, wird bei einem nachfolgenden Aufruf von EndReceive eine Ausnahme ausgelöst.

Mithilfe von EndReceive wird die Meldung, die das ReceiveCompleted-Ereignis verursacht hat, gelesen, d. h. aus der Warteschlange entfernt.

Wenn Sie mit dem asynchronen Empfangen von Meldungen fortfahren möchten, können Sie nach dem Aufruf von EndReceive erneut BeginReceive aufrufen.

Der folgenden Tabelle können Sie entnehmen, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus	Verfügbar
Lokaler Computer	Ja
Lokaler Computer + direkter Formatname	Ja
Remotecomputer	Nein
Lokaler Computer + direkter Formatname	Ja

Beispiel

Im folgenden Codebeispiel werden asynchrone Anforderungen verkettet. Dabei wird vorausgesetzt, dass auf dem lokalen Computer eine Warteschlange mit dem Namen "myQueue" vorhanden ist. Die Main-Funktion beginnt mit dem asynchronen Vorgang, der von der MyReceiveCompleted-Routine behandelt wird. MyReceiveCompleted verarbeitet die aktuelle Meldung und beginnt einen neuen asynchronen Receive-Vorgang.

Imports System
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 'Main



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

End Class 'MyNewQueue

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

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

package MyProject;
import System.*;
import System.Messaging.*;
import System.Threading.*;

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

    //**************************************************
    // Provides an entry point into the application.
    //         
    // This example performs asynchronous receive
    // operation processing.
    //**************************************************
    public static void main(String[] args)
    {
        // Create an instance of MessageQueue. Set its formatter.
        MessageQueue myQueue = new MessageQueue(".\\myQueue");
        myQueue.set_Formatter(new XmlMessageFormatter(new Type[] 
            { String.class.ToType() }));

        // Add an event handler for the ReceiveCompleted event.
        myQueue.add_ReceiveCompleted(new ReceiveCompletedEventHandler(
            MyReceiveCompleted));

        // Begin the asynchronous receive operation.
        myQueue.BeginReceive();
        signal.WaitOne();

        // Do other work on the current thread.

        return;
    } //main

    //***************************************************
    // 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.get_AsyncResult());

            count += 1;
            if (count == 10) {
                signal.Set();
            }

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

        // Handle other exceptions.

        return;
    } //MyReceiveCompleted
} //MyNewQueue

.NET Framework-Sicherheit

• Volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer. Dieser Member kann von nur teilweise vertrauenswürdigem Code nicht verwendet werden. Weitere Informationen finden Sie unter .

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0

Siehe auch

Referenz

MessageQueue-Klasse
MessageQueue-Member
System.Messaging-Namespace
BeginReceive
ReceiveCompleted