MessageQueue.ReceiveByCorrelationId メソッド (String)

指定した相関 ID と一致するメッセージを非トランザクション キューから受信します。現在、指定した相関 ID と一致するメッセージがキューに存在しない場合は、すぐに例外を発生させます。

Overloads Public Function ReceiveByCorrelationId( _
   ByVal correlationId As String _) As Message
[C#]
public Message ReceiveByCorrelationId(stringcorrelationId);
[C++]
public: Message* ReceiveByCorrelationId(String* correlationId);
[JScript]
public function ReceiveByCorrelationId(
   correlationId : String) : Message;

パラメータ

• correlationId
  受信するメッセージの CorrelationId 。

戻り値

渡された correlationId パラメータと一致する CorrelationId を持つ Message 。

例外

例外の種類	条件
ArgumentNullException	correlationId パラメータが null 参照 (Visual Basic では Nothing) です。
InvalidOperationException	指定した correlationId を持つメッセージは見つかりませんでした。
MessageQueueException	メッセージ キューの API にアクセスしたときにエラーが発生しました。

解説

このメソッドは、 MessageQueue が参照する非トランザクション キューで、 CorrelationId が指定した correlationId パラメータと一致するメッセージを検索します。 correlationID パラメータと一致するメッセージが見つからない場合は、例外がスローされます。見つかった場合、メッセージはキューから削除され、アプリケーションに返されます。

キューに送信したメッセージを、関連付けられている応答、レポート、または受信確認の各メッセージと結び付ける場合は、 CorrelationId プロパティを使用します。

その他の 2 つのメソッドを使用すると、キューからメッセージを受信できます。 Receive メソッドは、キューの最初のメッセージを返します。 ReceiveById メソッドは、一意な ID を指定してメッセージを取得します。

指定した相関 ID を持つメッセージをキューから削除せずに読み取るには、 PeekByCorrelationId メソッドを使用します。 PeekByCorrelationId メソッドは、常にキューの最初のメッセージを返します。そのため、より優先順位の高いメッセージがそのキューに到達するまで、後続の呼び出しでも同じメッセージが返されます。

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

ワークグループ モード	使用可否
ローカル コンピュータ	はい
ローカル コンピュータ + 直接書式名	はい
リモート コンピュータ	いいえ
リモート コンピュータ + 直接書式名	はい

使用例

[Visual Basic, C#, C++] オーダーを含んでいるメッセージをキューに送信し、またオーダーを含んでいるメッセージをキューから受信する例を次に示します。これは特に、元のメッセージがキューに到着するか、元のメッセージがキューから取得されたときに、肯定受信確認を要求します。

 
Imports System
Imports 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 sends and receives a message from
      ' a queue.
      '**************************************************
      Public Shared Sub Main()
         ' Create a new instance of the class.
         Dim myNewQueue As New MyNewQueue()
         
         ' Create new queues.
         CreateQueue(".\myQueue")
         CreateQueue(".\myAdministrationQueue")
         
         ' Send messages to a queue.
         myNewQueue.SendMessage()
         
         ' Receive messages from a queue.
         Dim messageId As String = myNewQueue.ReceiveMessage()
         
         ' Receive acknowledgment message.
         If Not (messageId Is Nothing) Then
            myNewQueue.ReceiveAcknowledgment(messageId, ".\myAdministrationQueue")
         End If
         
         Return
      End Sub 'Main
      
      
      '**************************************************
      ' Creates a new queue.
      '**************************************************
      Public Shared Sub CreateQueue(queuePath As String)
         Try
            If Not MessageQueue.Exists(queuePath) Then
               MessageQueue.Create(queuePath)
            Else
               Console.WriteLine((queuePath + " already exists."))
            End If
         Catch e As MessageQueueException
            Console.WriteLine(e.Message)
         End Try
      End Sub 'CreateQueue
       
      
      
      '**************************************************
      ' Sends a string message to a queue.
      '**************************************************
      Public Sub SendMessage()
         
         ' Connect to a queue on the local computer.
         Dim myQueue As New MessageQueue(".\myQueue")
         
         ' Create a new message.
         Dim myMessage As New Message("Original Message")
         
         myMessage.AdministrationQueue = New MessageQueue(".\myAdministrationQueue")
         myMessage.AcknowledgeType = AcknowledgeTypes.PositiveReceive Or AcknowledgeTypes.PositiveArrival
         
         ' Send the Order to the queue.
         myQueue.Send(myMessage)
         
         Return
      End Sub 'SendMessage
      
      
      
      '**************************************************
      ' Receives a message containing an Order.
      '**************************************************
      Public Function ReceiveMessage() As String
         ' Connect to the a queue on the local computer.
         Dim myQueue As New MessageQueue(".\myQueue")
         
         myQueue.MessageReadPropertyFilter.CorrelationId = True
         
         
         ' Set the formatter to indicate body contains an Order.
         myQueue.Formatter = New XmlMessageFormatter(New Type() {GetType(String)})
         
         Dim returnString As String = Nothing
         
         Try
            ' Receive and format the message. 
            Dim myMessage As Message = myQueue.Receive()
            
            
            ' Display message information.
            Console.WriteLine("____________________________________________")
            Console.WriteLine("Original message information--")
            Console.WriteLine(("Body: " + myMessage.Body.ToString()))
            Console.WriteLine(("Id: " + myMessage.Id.ToString()))
            Console.WriteLine("____________________________________________")
            
            returnString = myMessage.Id
         
         
         Catch
         ' Handle Message Queuing exceptions.
         
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         End Try
         
         ' Catch other exceptions as necessary.
         Return returnString
      End Function 'ReceiveMessage
      
      
      '**************************************************
      ' Receives a message containing an Order.
      '**************************************************
      Public Sub ReceiveAcknowledgment(messageId As String, queuePath As String)
         Dim found As Boolean = False
         Dim queue As New MessageQueue(queuePath)
         queue.MessageReadPropertyFilter.CorrelationId = True
         queue.MessageReadPropertyFilter.Acknowledgment = True
         
         Try
            While Not (queue.PeekByCorrelationId(messageId) Is Nothing)
               Dim myAcknowledgmentMessage As Message = queue.ReceiveByCorrelationId(messageId)
               
               ' Output acknowledgment message information. The correlation Id is identical
               ' to the id of the original message.
               Console.WriteLine("Acknowledgment Message Information--")
               Console.WriteLine(("Correlation Id: " + myAcknowledgmentMessage.CorrelationId.ToString()))
               Console.WriteLine(("Id: " + myAcknowledgmentMessage.Id.ToString()))
               Console.WriteLine(("Acknowledgment Type: " + myAcknowledgmentMessage.Acknowledgment.ToString()))
               Console.WriteLine("____________________________________________")
               
               found = True
            End While
         Catch e As InvalidOperationException
            ' This exception would be thrown if there is no (further) acknowledgment message
            ' with the specified correlation Id. Only output a message if there are no messages;
            ' not if the loop has found at least one.
            If found = False Then
               Console.WriteLine(e.Message)
            End If
         End Try 
      End Sub 'ReceiveAcknowledgment ' Handle other causes of invalid operation exception.
   End Class 'MyNewQueue
End Namespace 'MyProject 

[C#] 
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 sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Create new queues.
            CreateQueue(".\\myQueue");
            CreateQueue(".\\myAdministrationQueue");

            // Send messages to a queue.
            myNewQueue.SendMessage();

            // Receive messages from a queue.
            string messageId = myNewQueue.ReceiveMessage(); 

            // Receive acknowledgment message.
            if(messageId != null)
            {
                myNewQueue.ReceiveAcknowledgment(messageId, ".\\myAdministrationQueue");
            }

            return;
        }

        //**************************************************
        // Creates a new queue.
        //**************************************************

        public static void CreateQueue(string queuePath)
        {
            try    
            {
                if(!MessageQueue.Exists(queuePath))
                {
                    MessageQueue.Create(queuePath);
                }
                else
                {
                    Console.WriteLine(queuePath + " already exists.");
                }
            }
            catch (MessageQueueException e)
            {
                Console.WriteLine(e.Message);
            }
            
        }


        //**************************************************
        // Sends a string message to a queue.
        //**************************************************
        
        public void SendMessage()
        {

            // Connect to a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Create a new message.
            Message myMessage = new Message("Original Message"); 

            myMessage.AdministrationQueue = new MessageQueue(".\\myAdministrationQueue");
            myMessage.AcknowledgeType = AcknowledgeTypes.PositiveReceive | AcknowledgeTypes.PositiveArrival;

            // Send the Order to the queue.
            myQueue.Send(myMessage);

            return;
        }


        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  string ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            myQueue.MessageReadPropertyFilter.CorrelationId = true;


            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(string)});

            string returnString = null;
            
            try
            {
                // Receive and format the message. 
                Message myMessage =    myQueue.Receive(); 


                // Display message information.
                Console.WriteLine("____________________________________________");
                Console.WriteLine("Original message information--");
                Console.WriteLine("Body: " +myMessage.Body.ToString());
                Console.WriteLine("Id: " + myMessage.Id.ToString());
                Console.WriteLine("____________________________________________");

                returnString =  myMessage.Id;
                
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return returnString;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public void ReceiveAcknowledgment(string messageId, string queuePath)
        {
            bool found = false;
            MessageQueue queue = new MessageQueue(queuePath);
            queue.MessageReadPropertyFilter.CorrelationId = true;
            queue.MessageReadPropertyFilter.Acknowledgment = true;

            try
            {
                while(queue.PeekByCorrelationId(messageId) != null)
                {
                    Message myAcknowledgmentMessage = queue.ReceiveByCorrelationId(messageId);
            
                    // Output acknowledgment message information. The correlation Id is identical
                    // to the id of the original message.
                    Console.WriteLine("Acknowledgment Message Information--");
                    Console.WriteLine("Correlation Id: " + myAcknowledgmentMessage.CorrelationId.ToString());
                    Console.WriteLine("Id: " + myAcknowledgmentMessage.Id.ToString());
                    Console.WriteLine("Acknowledgment Type: " + myAcknowledgmentMessage.Acknowledgment.ToString());
                    Console.WriteLine("____________________________________________");

                    found = true;
                }
            }
            catch (InvalidOperationException e)
            { 
                // This exception would be thrown if there is no (further) acknowledgment message
                // with the specified correlation Id. Only output a message if there are no messages;
                // not if the loop has found at least one.
                if(found == false)
                {    
                    Console.WriteLine(e.Message);
                }

                // Handle other causes of invalid operation exception.
            }

        }
    }
}

[C++] 
#using <mscorlib.dll>
#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

__gc class MyNewQueue 
{
public:
    static void CreateQueue(String* queuePath) 
    {
        try 
        {
            if (!MessageQueue::Exists(queuePath)) 
            {
                MessageQueue::Create(queuePath);
            }
            else 
            {
                Console::WriteLine("{0} already exists.", queuePath );
            }
        } 
        catch (MessageQueueException* e) 
        {
            Console::WriteLine(e->Message);
        }

    }

public:
    void SendMessage() 
    {

        // Connect to a queue on the local computer.
        MessageQueue* myQueue = new MessageQueue(S".\\myQueue");

        // Create a new message.
        Message* myMessage = new Message(S"Original Message");
        myMessage->AdministrationQueue = new MessageQueue(S".\\myAdministrationQueue");
        myMessage->AcknowledgeType = (AcknowledgeTypes)(AcknowledgeTypes::PositiveReceive | AcknowledgeTypes::PositiveArrival);

        // Send the Order to the queue.
        myQueue->Send(myMessage);

        return;
    }



public:
    String* ReceiveMessage() 
    {
        // Connect to the a queue on the local computer.
        MessageQueue* myQueue = new MessageQueue(S".\\myQueue");

        myQueue->MessageReadPropertyFilter->CorrelationId = true;

        Type* p __gc[] = new Type*[1];
        p[0] =    __typeof(String);
        myQueue->Formatter = new XmlMessageFormatter( p );

        String* returnString = 0;

        try 
        {
            // Receive and format the message. 
            Message* myMessage = myQueue->Receive(); 

            // Display message information.
            Console::WriteLine(S"____________________________________________");
            Console::WriteLine(S"Original message information--");
            Console::WriteLine(S"Body: {0}", myMessage->Body);
            Console::WriteLine(S"Id: {0}", myMessage->Id);
            Console::WriteLine(S"____________________________________________");

            returnString =  myMessage->Id;

        }
        catch (MessageQueueException*) 
        {
            // Handle Message Queuing exceptions.
        }

        // Handle invalid serialization format.
        catch (InvalidOperationException* e) 
        {
            Console::WriteLine(e->Message);
        }

        // Catch other exceptions as necessary.

        return returnString;
    }

public:
    void ReceiveAcknowledgment(String* messageId, String* queuePath) 
    {
        bool found = false;
        MessageQueue* queue = new MessageQueue(queuePath);
        queue->MessageReadPropertyFilter->CorrelationId = true;
        queue->MessageReadPropertyFilter->Acknowledgment = true;

        try 
        {
            while(queue->PeekByCorrelationId(messageId) != 0) 
            {
                Message* myAcknowledgmentMessage = queue->ReceiveByCorrelationId(messageId);

                // Output acknowledgment message information. The correlation Id is identical
                // to the id of the original message.
                Console::WriteLine(S"Acknowledgment Message Information--");
                Console::WriteLine(S"Correlation Id: {0}", myAcknowledgmentMessage->CorrelationId);
                Console::WriteLine(S"Id: {0}", myAcknowledgmentMessage->Id);
                Console::WriteLine(S"Acknowledgment Type: {0}", __box(myAcknowledgmentMessage->Acknowledgment));
                Console::WriteLine(S"____________________________________________");

                found = true;
            }
        } 
        catch (InvalidOperationException* e) 
        { 
            // This exception would be thrown if there is no (further) acknowledgment message
            // with the specified correlation Id. Only output a message if there are no messages;
            // not if the loop has found at least one.
            if (found == false)
            {    
                Console::WriteLine(e->Message);
            }

            // Handle other causes of invalid operation exception.
        }

    }
};

int main() 
{
    // Create a new instance of the class.
    MyNewQueue* myNewQueue = new MyNewQueue();

    // Create new queues.
    MyNewQueue::CreateQueue(S".\\myQueue");
    MyNewQueue::CreateQueue(S".\\myAdministrationQueue");

    // Send messages to a queue.
    myNewQueue->SendMessage();

    // Receive messages from a queue.
    String* messageId = myNewQueue->ReceiveMessage(); 

    // Receive acknowledgment message.
    if (messageId != 0) 
    {
        myNewQueue->ReceiveAcknowledgment(messageId, S".\\myAdministrationQueue");
    }

    return 0;
}

[JScript] JScript のサンプルはありません。Visual Basic、C#、および C++ のサンプルを表示するには、このページの左上隅にある言語のフィルタ ボタン をクリックします。

必要条件

プラットフォーム: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 ファミリ

.NET Framework セキュリティ:

• 直前の呼び出し元の完全信頼。このメンバは、部分的に信頼されているコードから使用することはできません。詳細の参照先 : 部分信頼コードからのライブラリの使用

参照

MessageQueue クラス | MessageQueue メンバ | System.Messaging 名前空間 | MessageQueue.ReceiveByCorrelationId オーバーロードの一覧 | Receive | ReceiveById | Peek | BeginReceive