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

.NET Framework のセキュリティ

直前の呼び出し元に対する完全な信頼。このメンバは、部分的に信頼されているコードから使用することはできません。詳細については、「」を参照してください。

プラットフォーム

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

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0

参照

関連項目
MessageQueue クラス
MessageQueue メンバ
System.Messaging 名前空間
BeginReceive
ReceiveCompleted

このページでは「.NET Framework クラスライブラリリファレンス」からMessageQueue.EndReceive メソッドを検索した結果を表示しています。
Weblioに収録されているすべての辞書からMessageQueue.EndReceive メソッドを検索する場合は、下記のリンクをクリックしてください。

全ての辞書からMessageQueue.EndReceive メソッドを検索

>> 「MessageQueue.EndReceive メソッド」を含む用語の索引
MessageQueue.EndReceive メソッドのページへのリンク

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

MessageQueue.EndReceive メソッド

「MessageQueue.EndReceive メソッド」の関連用語


	© 2025 Microsoft.All rights reserved.

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

MessageQueue.EndReceive メソッド

急上昇のことば

「MessageQueue.EndReceive メソッド」の関連用語

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