MessageQueue.EndReceive メソッドとは何？わかりやすく解説 Weblio辞書

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

MessageQueue.EndReceive メソッド

指定した非同期の受信操作を完了します。

名前空間: System.Messaging
アセンブリ: System.Messaging (system.messaging.dll 内)
構文

Visual Basic (宣言)

Public Function EndReceive ( _
    asyncResult As IAsyncResult _
) As Message

Visual Basic (使用法)

Dim instance As MessageQueue
Dim asyncResult As IAsyncResult
Dim returnValue As Message

returnValue = instance.EndReceive(asyncResult)

public Message EndReceive (
    IAsyncResult asyncResult
)

C++

public:
Message^ EndReceive (
    IAsyncResult^ asyncResult
)

public Message EndReceive (
    IAsyncResult asyncResult
)

JScript

public function EndReceive (
    asyncResult : IAsyncResult
) : Message

パラメータ

asyncResult: 完了する非同期の受信操作を識別する IAsyncResult。ここから終了結果が取得されます。

戻り値
完了する非同期操作に関連付けられた Message。

例外

例外の種類	条件
ArgumentNullException	asyncResult パラメータが null 参照 (Visual Basic では Nothing) です。
ArgumentException	asyncResult パラメータの構文が無効です。
MessageQueueException	メッセージキューのメソッドにアクセスしたときにエラーが発生しました。

解説

ReceiveCompleted イベントが発生したときに、EndReceive は BeginReceive 呼び出しで開始された操作を完了します。操作を完了するために、EndReceive はメッセージを受信します。

BeginReceive はタイムアウトを指定できます。タイムアウトを指定すると、キューにメッセージが到達する前にタイムアウトが発生した場合に、ReceiveCompleted イベントが発生します。この場合、asyncResult パラメータの IsCompleted プロパティは true に設定されますが、メッセージは操作に関連付けられません。メッセージがキューに到達する前にタイムアウトが発生すると、後続の EndReceive 呼び出しは例外をスローします。

ReceiveCompleted イベントを発生させたメッセージを読み取る (キューから削除する) には、EndReceive を使用します。

メッセージを非同期に受信し続けるには、EndReceive を呼び出した後でもう一度 BeginReceive を呼び出します。

このメソッドが各種のワークグループモードで使用できるかどうかを次の表に示します。

ワークグループモード	使用可否
ローカルコンピュータ	○
ローカルコンピュータと直接書式名	○
リモートコンピュータ	×
リモートコンピュータと直接書式名	○

使用例

非同期要求をチェーンするコード例を次に示します。ローカルコンピュータに "myQueue" というキューがあることを前提にしています。Main 関数は、MyReceiveCompleted ルーチンで処理される非同期操作を開始します。MyReceiveCompleted は現在のメッセージを処理し、新しい非同期の受信操作を開始します。

Visual Basic

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

C++

#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