MessageQueue.ReceiveByCorrelationId 메서드

참조

정의

네임스페이스:: System.Messaging

어셈블리:: System.Messaging.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

주어진 상관 관계 식별자를 갖는 메시지를 받습니다.

오버로드

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)	주어진 상관 관계 식별자를 갖는 메시지를 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)	주어진 상관 관계 식별자를 갖는 메시지를 트랜잭션 큐로부터 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
ReceiveByCorrelationId(String, TimeSpan)	주어진 상관 관계 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
ReceiveByCorrelationId(String, MessageQueueTransactionType)	주어진 상관 관계 식별자를 갖는 메시지를 받습니다. 지정된 상관 관계 식별자가 들어 있는 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.
ReceiveByCorrelationId(String, MessageQueueTransaction)	주어진 상관 관계 식별자를 갖는 메시지를 트랜잭션 큐로부터 받습니다. 지정된 상관 관계 식별자가 포함된 메시지가 큐에 현재 존재하지 않는 경우에는 바로 예외가 발생합니다.
ReceiveByCorrelationId(String)	주어진 상관 관계 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받습니다. 지정된 상관 관계 식별자가 포함된 메시지가 큐에 현재 존재하지 않는 경우에는 바로 예외가 발생합니다.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)

주어진 상관 관계 식별자를 갖는 메시지를 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.

public:
 System::Messaging::Message ^ ReceiveByCorrelationId(System::String ^ correlationId, TimeSpan timeout, System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message ReceiveByCorrelationId (string correlationId, TimeSpan timeout, System.Messaging.MessageQueueTransactionType transactionType);

member this.ReceiveByCorrelationId : string * TimeSpan * System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function ReceiveByCorrelationId (correlationId As String, timeout As TimeSpan, transactionType As MessageQueueTransactionType) As Message

매개 변수

correlationId: String

받을 메시지의 CorrelationId입니다.

timeout: TimeSpan

새 메시지를 검사할 수 있을 때까지 기다리는 시간을 나타내는 TimeSpan입니다.

transactionType: MessageQueueTransactionType

MessageQueueTransactionType 값 중 하나로, 메시지와 연결할 트랜잭션 컨텍스트 형식을 설명합니다.

반환

Message

전달된 correlationId 매개 변수와 Message가 일치하는 CorrelationId를 반환합니다.

예외

ArgumentNullException

correlationId 매개 변수가 null인 경우

InvalidOperationException

지정된 correlationId의 메시지를 찾을 수 없는 경우

ArgumentException

timeout 매개 변수에 지정된 값이 잘못된 경우. timeout이 Zero보다 작거나 InfiniteTimeout보다 클 수 있습니다.

InvalidEnumArgumentException

transactionType 매개 변수가 MessageQueueTransactionType 멤버 중 하나가 아닌 경우

MessageQueueException

지정된 correlationId가 들어 있는 메시지가 큐에 없고 제한 시간이 만료되기 전에 도착하지 않았습니다.

또는

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)의 사용법을 보여줍니다.


// Connect to a nontransactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message to the nontransactional queue.
queue->Send(msg, "Example Message Label");

// Get the message's Id property value.
String^ id = msg->Id;

// Receive the message from the nontransactional queue.
msg = queue->ReceiveById(id, TimeSpan::FromSeconds(10.0));

// Connect to a transactional queue on the local computer.
MessageQueue^ transQueue = 
    gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message in response to the original message.
Message^ responseMsg = gcnew Message("Example Response Message Body");

// Set the response message's CorrelationId property value to the Id
// property value of the original message.
responseMsg->CorrelationId = id;

// Send the response message to the transactional queue.
transQueue->Send(responseMsg, "Example Response Message Label",
    MessageQueueTransactionType::Single);

// Set the transactional queue's MessageReadPropertyFilter property to
// ensure that the response message includes the desired properties.
transQueue->MessageReadPropertyFilter->CorrelationId = true;

// Receive the response message from the transactional queue.
responseMsg = transQueue->ReceiveByCorrelationId(id,
    TimeSpan::FromSeconds(10.0), MessageQueueTransactionType::Single);

// Display the response message's property values.
Console::WriteLine("Message.Label: {0}", responseMsg->Label);
Console::WriteLine("Message.CorrelationId: {0}",
    responseMsg->CorrelationId);

transQueue->Close();
queue->Close();


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

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message to the nontransactional queue.
queue.Send(msg, "Example Message Label");

// Get the message's Id property value.
string id = msg.Id;

// Receive the message from the nontransactional queue.
msg = queue.ReceiveById(id, TimeSpan.FromSeconds(10.0));

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

// Create a new message in response to the original message.
Message responseMsg = new Message("Example Response Message Body");

// Set the response message's CorrelationId property value to the Id
// property value of the original message.
responseMsg.CorrelationId = id;

// Send the response message to the transactional queue.
transQueue.Send(responseMsg, "Example Response Message Label",
    MessageQueueTransactionType.Single);

// Set the transactional queue's MessageReadPropertyFilter property to
// ensure that the response message includes the desired properties.
transQueue.MessageReadPropertyFilter.CorrelationId = true;

// Receive the response message from the transactional queue.
responseMsg = transQueue.ReceiveByCorrelationId(id,
    TimeSpan.FromSeconds(10.0), MessageQueueTransactionType.Single);

// Display the response message's property values.
Console.WriteLine("Message.Label: {0}", responseMsg.Label);
Console.WriteLine("Message.CorrelationId: {0}",
    responseMsg.CorrelationId);

설명

이 메서드는 지정된 매개 변수와 일치하는 메시지에 CorrelationId 대해 에서 참조 MessageQueue 하는 correlationId 큐를 찾습니다. 이 메서드는 매개 변수로 지정된 상관 관계 식별자가 있는 메시지가 매개 변수로 correlationId 정의된 transactionType 트랜잭션 컨텍스트를 사용하여 큐에 있는 경우 즉시 반환됩니다. 그렇지 않으면 메서드는 지정된 기간 동안 새 메시지가 도착할 때까지 기다립니다. 제한 시간이 만료되기 전에 새 메시지가 도착하지 않으면 예외가 throw됩니다.

매개 변수는 timeout 이 메서드의 총 실행 시간을 지정하지 않습니다. 대신 새 메시지가 큐에 도착할 때까지 기다리는 시간을 지정합니다. 새 메시지가 도착할 때마다 이 메서드는 CorrelationId 새 메시지의 를 검사하여 매개 변수와 correlationId 일치하는지 확인합니다. 그렇지 않은 경우 이 메서드는 시간 제한 기간을 시작하고 다른 새 메시지가 도착할 때까지 기다립니다. 따라서 새 메시지가 제한 시간 내에 계속 도착하는 경우 이 메서드는 새 메시지가 도착하지 않고 제한 시간이 만료될 때까지 또는 매개 변수와 일치하는 correlationId 메시지가 도착할 때까지 무기한 실행을 계속할 수 있습니다CorrelationId. 메시지를 수신하는 transactionType 데 사용할 스레드에 연결된 외부 트랜잭션 컨텍스트가 이미 있는 경우 매개 변수를 지정 Automatic 합니다. Single 메시지를 단일 내부 트랜잭션으로 받을지 지정합니다. 트랜잭션 컨텍스트 외부의 트랜잭션 큐에서 메시지를 받을지 지정할 수 있습니다 None .

트랜잭션 큐에서 메시지를 수신하기 위해 이 메서드를 호출하면 트랜잭션이 중단된 경우 수신된 메시지가 큐로 반환됩니다. 트랜잭션이 커밋될 때까지 메시지는 큐에서 영구적으로 제거되지 않습니다.

속성은 CorrelationId 연결된 응답, 보고서 또는 승인 메시지에 큐에 전송된 메시지를 연결하는 데 사용됩니다.

다른 두 가지 메서드를 사용하면 큐에서 메시지를 받을 수 있습니다. 메서드는 Receive 큐의 첫 번째 메시지를 반환하고 ReceiveById(String) 메서드는 고유 식별자를 지정하여 메시지를 검색하는 데 사용됩니다.

지정된 상관 관계 식별자가 있는 메시지를 큐에서 제거하지 않고 읽으려면 메서드를 PeekByCorrelationId(String) 사용합니다. 메서드는 PeekByCorrelationId(String) 항상 큐에서 첫 번째 메시지를 반환하므로 우선 순위가 높은 메시지가 큐에 도착하지 않는 한 메서드에 대한 후속 호출은 동일한 메시지를 반환합니다. 에 대한 호출 PeekByCorrelationId(String)에서 반환된 메시지와 연결된 트랜잭션 컨텍스트가 없습니다. 는 PeekByCorrelationId(String) 큐에서 메시지를 제거하지 않으므로 트랜잭션이 중단된 경우 롤백할 것이 없습니다.

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

적용 대상

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)

주어진 상관 관계 식별자를 갖는 메시지를 트랜잭션 큐로부터 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.

public:
 System::Messaging::Message ^ ReceiveByCorrelationId(System::String ^ correlationId, TimeSpan timeout, System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message ReceiveByCorrelationId (string correlationId, TimeSpan timeout, System.Messaging.MessageQueueTransaction transaction);

member this.ReceiveByCorrelationId : string * TimeSpan * System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function ReceiveByCorrelationId (correlationId As String, timeout As TimeSpan, transaction As MessageQueueTransaction) As Message

매개 변수

correlationId: String

받을 메시지의 CorrelationId입니다.

timeout: TimeSpan

새 메시지를 검사할 수 있을 때까지 기다리는 시간을 나타내는 TimeSpan입니다.

transaction: MessageQueueTransaction

MessageQueueTransaction 개체

반환

Message

전달된 correlationId 매개 변수와 Message가 일치하는 CorrelationId를 반환합니다.

예외

ArgumentNullException

correlationId 매개 변수가 null인 경우

또는

transaction 매개 변수가 null인 경우

ArgumentException

timeout 매개 변수에 지정된 값이 잘못된 경우. timeout이 Zero보다 작거나 InfiniteTimeout보다 클 수 있습니다.

MessageQueueException

지정된 correlationId가 들어 있는 메시지가 큐에 없고 제한 시간이 만료되기 전에 도착하지 않았습니다.

또는

비트랜잭션 큐입니다.

또는

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)의 사용법을 보여줍니다.


// Connect to a nontransactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message to the nontransactional queue.
queue->Send(msg, "Example Message Label");

// Get the message's Id property value.
String^ id = msg->Id;

// Receive the message from the nontransactional queue.
msg = queue->ReceiveById(id, TimeSpan::FromSeconds(10.0));

// Connect to a transactional queue on the local computer.
MessageQueue^ transQueue = 
    gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message in response to the original message.
Message^ responseMsg = gcnew Message("Example Response Message Body");

// Set the response message's CorrelationId property value to the Id
// property value of the original message.
responseMsg->CorrelationId = id;

// Send the response message to the transactional queue.
transQueue->Send(responseMsg, "Example Response Message Label",
    MessageQueueTransactionType::Single);

// Set the transactional queue's MessageReadPropertyFilter property to
// ensure that the response message includes the desired properties.
transQueue->MessageReadPropertyFilter->CorrelationId = true;

// Create a message queuing transaction.
MessageQueueTransaction^ transaction = gcnew MessageQueueTransaction();

try
{
    // Begin a transaction.
    transaction->Begin();

    // Receive the response message from the transactional queue.
    responseMsg = transQueue->ReceiveByCorrelationId(id,
        TimeSpan::FromSeconds(10.0), transaction);

    // Commit the transaction.
    transaction->Commit();
}
catch (Exception^ ex)
{
    // Cancel the transaction.
    transaction->Abort();

    // Propagate the exception.
    throw ex;
}
finally
{
    // Dispose of the transaction object.
    delete transaction;
    transQueue->Close();
    queue->Close();
}

// Display the response message's property values.
Console::WriteLine("Message.Label: {0}", responseMsg->Label);
Console::WriteLine("Message.CorrelationId: {0}",
    responseMsg->CorrelationId);


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

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message to the nontransactional queue.
queue.Send(msg, "Example Message Label");

// Get the message's Id property value.
string id = msg.Id;

// Receive the message from the nontransactional queue.
msg = queue.ReceiveById(id, TimeSpan.FromSeconds(10.0));

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

// Create a new message in response to the original message.
Message responseMsg = new Message("Example Response Message Body");

// Set the response message's CorrelationId property value to the Id
// property value of the original message.
responseMsg.CorrelationId = id;

// Send the response message to the transactional queue.
transQueue.Send(responseMsg, "Example Response Message Label",
    MessageQueueTransactionType.Single);

// Set the transactional queue's MessageReadPropertyFilter property to
// ensure that the response message includes the desired properties.
transQueue.MessageReadPropertyFilter.CorrelationId = true;

// Create a message queuing transaction.
MessageQueueTransaction transaction = new MessageQueueTransaction();

try
{
    // Begin a transaction.
    transaction.Begin();

    // Receive the response message from the transactional queue.
    responseMsg = transQueue.ReceiveByCorrelationId(id,
        TimeSpan.FromSeconds(10.0), transaction);

    // Commit the transaction.
    transaction.Commit();
}
catch(System.Exception e)
{
    // Cancel the transaction.
    transaction.Abort();

    // Propagate the exception.
    throw e;
}
finally
{
    // Dispose of the transaction object.
    transaction.Dispose();
}

// Display the response message's property values.
Console.WriteLine("Message.Label: {0}", responseMsg.Label);
Console.WriteLine("Message.CorrelationId: {0}",
    responseMsg.CorrelationId);

설명

이 메서드는 지정된 correlationId 매개 변수와 일치하는 메시지에 CorrelationId 대해 에서 참조 MessageQueue 하는 트랜잭션 큐를 찾습니다. 매개 변수로 지정된 상관 관계 식별자가 있는 메시지가 매개 변수로 correlationId 정의된 transaction 내부 트랜잭션 컨텍스트를 사용하여 큐에 있는 경우 이 메서드는 즉시 를 반환합니다. 그렇지 않으면 메서드는 지정된 기간 동안 새 메시지가 도착할 때까지 기다립니다. 제한 시간이 만료되기 전에 새 메시지가 도착하지 않으면 예외가 throw됩니다.

이 메서드는 트랜잭션 큐에서 호출되므로 트랜잭션이 중단되면 수신된 메시지가 큐로 반환됩니다. 트랜잭션이 커밋될 때까지 메시지는 큐에서 영구적으로 제거되지 않습니다.

속성은 CorrelationId 연결된 응답, 보고서 또는 승인 메시지에 큐에 전송된 메시지를 연결하는 데 사용됩니다.

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

적용 대상

ReceiveByCorrelationId(String, TimeSpan)

주어진 상관 관계 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.

public:
 System::Messaging::Message ^ ReceiveByCorrelationId(System::String ^ correlationId, TimeSpan timeout);

public System.Messaging.Message ReceiveByCorrelationId (string correlationId, TimeSpan timeout);

member this.ReceiveByCorrelationId : string * TimeSpan -> System.Messaging.Message

Public Function ReceiveByCorrelationId (correlationId As String, timeout As TimeSpan) As Message

매개 변수

correlationId: String

받을 메시지의 CorrelationId입니다.

timeout: TimeSpan

새 메시지를 검사할 수 있을 때까지 기다리는 시간을 나타내는 TimeSpan입니다.

반환

Message

전달된 correlationId 매개 변수와 Message가 일치하는 CorrelationId를 반환합니다.

예외

ArgumentNullException

correlationId 매개 변수가 null인 경우

ArgumentException

timeout 매개 변수에 지정된 값이 잘못된 경우. timeout이 Zero보다 작거나 InfiniteTimeout보다 클 수 있습니다.

MessageQueueException

지정된 correlationId가 들어 있는 메시지가 큐에 없고 제한 시간이 만료되기 전에 도착하지 않았습니다.

또는

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 ReceiveByCorrelationId(String, TimeSpan)의 사용법을 보여줍니다.


// Connect to a queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Designate a queue to receive the acknowledgement message for this
// message.
msg->AdministrationQueue = 
    gcnew MessageQueue(".\\exampleAdminQueue");

// Set the message to generate an acknowledgement message upon its
// arrival.
msg->AcknowledgeType = AcknowledgeTypes::PositiveArrival;

// Send the message.
queue->Send(msg, "Example Message Label");

// Get the message's Id property value.
String^ id = msg->Id;

// Receive the message from the queue.
msg = queue->ReceiveById(id, TimeSpan::FromSeconds(10.0));

// Connect to the admin queue.
MessageQueue^ adminQueue = 
    gcnew MessageQueue(".\\exampleAdminQueue");

// Set the admin queue's MessageReadPropertyFilter property to ensure
// that the acknowledgement message includes the desired properties.
adminQueue->MessageReadPropertyFilter->Acknowledgment = true;
adminQueue->MessageReadPropertyFilter->CorrelationId = true;

// Receive the acknowledgement message from the admin queue.
Message^ ackMsg = adminQueue->ReceiveByCorrelationId(id,
    TimeSpan::FromSeconds(10.0));

// Display the acknowledgement message's property values.
Console::WriteLine("Message.Label: {0}", ackMsg->Label);
Console::WriteLine("Message.Acknowledgment: {0}",
    ackMsg->Acknowledgment);
Console::WriteLine("Message.CorrelationId: {0}", ackMsg->CorrelationId);

adminQueue->Close();
queue->Close();


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

// Create a new message.
Message msg = new Message("Example Message Body");

// Designate a queue to receive the acknowledgement message for this
// message.
msg.AdministrationQueue = new MessageQueue(".\\exampleAdminQueue");

// Set the message to generate an acknowledgement message upon its
// arrival.
msg.AcknowledgeType = AcknowledgeTypes.PositiveArrival;

// Send the message.
queue.Send(msg, "Example Message Label");

// Get the message's Id property value.
string id = msg.Id;

// Receive the message from the queue.
msg = queue.ReceiveById(id, TimeSpan.FromSeconds(10.0));

// Connect to the admin queue.
MessageQueue adminQueue = new MessageQueue(".\\exampleAdminQueue");

// Set the admin queue's MessageReadPropertyFilter property to ensure
// that the acknowledgement message includes the desired properties.
adminQueue.MessageReadPropertyFilter.Acknowledgment = true;
adminQueue.MessageReadPropertyFilter.CorrelationId = true;

// Receive the acknowledgement message from the admin queue.
Message ackMsg = adminQueue.ReceiveByCorrelationId(id,
    TimeSpan.FromSeconds(10.0));

// Display the acknowledgement message's property values.
Console.WriteLine("Message.Label: {0}", ackMsg.Label);
Console.WriteLine("Message.Acknowledgment: {0}", ackMsg.Acknowledgment);
Console.WriteLine("Message.CorrelationId: {0}", ackMsg.CorrelationId);

설명

이 메서드는 지정된 매개 변수와 일치하는 메시지에 CorrelationId 대해 에서 참조 MessageQueue 하는 비 트랜잭션 큐를 찾습니다correlationId. 매개 변수에 지정된 correlationId 상관 관계 식별자가 있는 메시지가 큐에 있는 경우 이 메서드는 즉시 를 반환합니다. 그렇지 않으면 메서드는 지정된 기간 동안 새 메시지가 도착할 때까지 기다립니다. 제한 시간이 만료되기 전에 새 메시지가 도착하지 않으면 예외가 throw됩니다.

매개 변수는 timeout 이 메서드의 총 실행 시간을 지정하지 않습니다. 대신 새 메시지가 큐에 도착할 때까지 기다리는 시간을 지정합니다. 새 메시지가 도착할 때마다 이 메서드는 새 메시지의 를 CorrelationId 검사하여 매개 변수와 correlationId 일치하는지 확인합니다. 그렇지 않은 경우 이 메서드는 시간 제한 기간을 시작하고 다른 새 메시지가 도착할 때까지 기다립니다. 따라서 새 메시지가 제한 시간 내에 계속 도착하는 경우 새 메시지가 도착하지 않고 제한 시간이 만료되거나 매개 변수와 일치하는 correlationId 메시지가 도착할 때까지 이 메서드가 무기한으로 계속 실행될 수 있습니다CorrelationId.

속성은 CorrelationId 연결된 응답, 보고서 또는 승인 메시지에 큐에 전송된 메시지를 연결하는 데 사용됩니다.

다른 두 가지 방법을 사용하면 큐에서 메시지를 받을 수 있습니다. 메서드는 Receive 큐의 첫 번째 메시지를 반환하고 ReceiveById(String) 메서드는 고유 식별자를 지정하여 메시지를 검색하는 데 사용됩니다.

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

적용 대상

ReceiveByCorrelationId(String, MessageQueueTransactionType)

주어진 상관 관계 식별자를 갖는 메시지를 받습니다. 지정된 상관 관계 식별자가 들어 있는 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.

public:
 System::Messaging::Message ^ ReceiveByCorrelationId(System::String ^ correlationId, System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message ReceiveByCorrelationId (string correlationId, System.Messaging.MessageQueueTransactionType transactionType);

member this.ReceiveByCorrelationId : string * System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function ReceiveByCorrelationId (correlationId As String, transactionType As MessageQueueTransactionType) As Message

매개 변수

correlationId: String

받을 메시지의 CorrelationId입니다.

transactionType: MessageQueueTransactionType

MessageQueueTransactionType 값 중 하나로, 메시지와 연결할 트랜잭션 컨텍스트 형식을 설명합니다.

반환

Message

전달된 correlationId 매개 변수와 Message가 일치하는 CorrelationId를 반환합니다.

예외

ArgumentNullException

correlationId 매개 변수가 null인 경우

InvalidOperationException

지정된 correlationId의 메시지를 찾을 수 없는 경우

InvalidEnumArgumentException

transactionType 매개 변수가 MessageQueueTransactionType 멤버 중 하나가 아닌 경우

MessageQueueException

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 ReceiveByCorrelationId(String, MessageQueueTransactionType)의 사용법을 보여줍니다.


// Connect to a nontransactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message to the nontransactional queue.
queue->Send(msg, "Example Message Label");

// Get the message's Id property value.
String^ id = msg->Id;

// Receive the message from the nontransactional queue.
msg = queue->ReceiveById(id, TimeSpan::FromSeconds(10.0));

// Connect to a transactional queue on the local computer.
MessageQueue^ transQueue = 
    gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message in response to the original message.
Message^ responseMsg = gcnew Message("Example Response Message Body");

// Set the response message's CorrelationId property value to the Id
// property value of the original message.
responseMsg->CorrelationId = id;

// Send the response message to the transactional queue.
transQueue->Send(responseMsg, "Example Response Message Label",
    MessageQueueTransactionType::Single);

// Simulate doing other work so the message has time to arrive.
System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));

// Set the transactional queue's MessageReadPropertyFilter property to
// ensure that the response message includes the desired properties.
transQueue->MessageReadPropertyFilter->CorrelationId = true;

// Receive the response message from the transactional queue.
responseMsg = transQueue->ReceiveByCorrelationId(id,
    MessageQueueTransactionType::Single);

// Display the response message's property values.
Console::WriteLine("Message.Label: {0}", responseMsg->Label);
Console::WriteLine("Message.CorrelationId: {0}",
    responseMsg->CorrelationId);

transQueue->Close();
queue->Close();


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

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message to the nontransactional queue.
queue.Send(msg, "Example Message Label");

// Get the message's Id property value.
string id = msg.Id;

// Receive the message from the nontransactional queue.
msg = queue.ReceiveById(id, TimeSpan.FromSeconds(10.0));

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

// Create a new message in response to the original message.
Message responseMsg = new Message("Example Response Message Body");

// Set the response message's CorrelationId property value to the Id
// property value of the original message.
responseMsg.CorrelationId = id;

// Send the response message to the transactional queue.
transQueue.Send(responseMsg, "Example Response Message Label",
    MessageQueueTransactionType.Single);

// Simulate doing other work so the message has time to arrive.
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

// Set the transactional queue's MessageReadPropertyFilter property to
// ensure that the response message includes the desired properties.
transQueue.MessageReadPropertyFilter.CorrelationId = true;

// Receive the response message from the transactional queue.
responseMsg = transQueue.ReceiveByCorrelationId(id,
    MessageQueueTransactionType.Single);

// Display the response message's property values.
Console.WriteLine("Message.Label: {0}", responseMsg.Label);
Console.WriteLine("Message.CorrelationId: {0}",
    responseMsg.CorrelationId);

설명

이 메서드는 에서 참조하는 MessageQueue 큐에서 지정된 매개 변수와 CorrelationId 일치하는 메시지를 찾습니다 correlationId . 매개 변수와 일치하는 correlationID 메시지가 없으면 예외가 throw됩니다. 메시지 큐에서 제거 되 고 정의한 트랜잭션 컨텍스트를 사용 하 여 애플리케이션에 반환 되는 고, 그렇지는 transactionType 매개 변수입니다.

메시지를 수신하는 transactionType 데 사용할 스레드에 연결된 외부 트랜잭션 컨텍스트가 이미 있는 경우 매개 변수에 를 지정 Automatic 합니다. Single 메시지를 단일 내부 트랜잭션으로 받을지 지정합니다. 트랜잭션 컨텍스트 외부의 트랜잭션 큐에서 메시지를 받을지 지정할 수 있습니다 None .

트랜잭션 큐에서 메시지를 수신하기 위해 이 메서드를 호출하면 트랜잭션이 중단되면 수신된 메시지가 큐로 반환됩니다. 트랜잭션이 커밋될 때까지 메시지는 큐에서 영구적으로 제거되지 않습니다.

속성은 CorrelationId 연결된 응답, 보고서 또는 승인 메시지에 큐에 전송된 메시지를 연결하는 데 사용됩니다.

큐에서 메시지를 제거하지 않고 지정된 상관 관계 식별자가 있는 메시지를 읽으려면 메서드를 PeekByCorrelationId(String) 사용합니다. 메서드는 PeekByCorrelationId(String) 항상 큐의 첫 번째 메시지를 반환하므로 우선 순위가 높은 메시지가 큐에 도착하지 않는 한 메서드에 대한 후속 호출은 동일한 메시지를 반환합니다. 에 대한 호출 PeekByCorrelationId(String)에서 반환된 메시지와 연결된 트랜잭션 컨텍스트가 없습니다. 는 PeekByCorrelationId(String) 큐의 메시지를 제거하지 않으므로 트랜잭션이 중단된 경우 롤백할 것이 없습니다.

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

적용 대상

ReceiveByCorrelationId(String, MessageQueueTransaction)

주어진 상관 관계 식별자를 갖는 메시지를 트랜잭션 큐로부터 받습니다. 지정된 상관 관계 식별자가 포함된 메시지가 큐에 현재 존재하지 않는 경우에는 바로 예외가 발생합니다.

public:
 System::Messaging::Message ^ ReceiveByCorrelationId(System::String ^ correlationId, System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message ReceiveByCorrelationId (string correlationId, System.Messaging.MessageQueueTransaction transaction);

member this.ReceiveByCorrelationId : string * System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function ReceiveByCorrelationId (correlationId As String, transaction As MessageQueueTransaction) As Message

매개 변수

correlationId: String

받을 메시지의 CorrelationId입니다.

transaction: MessageQueueTransaction

MessageQueueTransaction 개체

반환

Message

전달된 correlationId 매개 변수와 Message가 일치하는 CorrelationId를 반환합니다.

예외

ArgumentNullException

correlationId 매개 변수가 null인 경우

또는

transaction 매개 변수가 null인 경우

InvalidOperationException

지정된 correlationId의 메시지를 찾을 수 없는 경우

MessageQueueException

비트랜잭션 큐입니다.

또는

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 ReceiveByCorrelationId(String, MessageQueueTransaction)의 사용법을 보여줍니다.


// Connect to a nontransactional queue on the local computer.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message to the nontransactional queue.
queue->Send(msg, "Example Message Label");

// Get the message's Id property value.
String^ id = msg->Id;

// Receive the message from the nontransactional queue.
msg = queue->ReceiveById(id, TimeSpan::FromSeconds(10.0));

// Connect to a transactional queue on the local computer.
MessageQueue^ transQueue = 
    gcnew MessageQueue(".\\exampleTransQueue");

// Create a new message in response to the original message.
Message^ responseMsg = gcnew Message("Example Response Message Body");

// Set the response message's CorrelationId property value to the Id
// property value of the original message.
responseMsg->CorrelationId = id;

// Send the response message to the transactional queue.
transQueue->Send(responseMsg, "Example Response Message Label",
    MessageQueueTransactionType::Single);

// Simulate doing other work so the message has time to arrive.
System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));

// Set the transactional queue's MessageReadPropertyFilter property to
// ensure that the response message includes the desired properties.
transQueue->MessageReadPropertyFilter->CorrelationId = true;

// Create a message queuing transaction.
MessageQueueTransaction^ transaction = gcnew MessageQueueTransaction();

try
{
    // Begin a transaction.
    transaction->Begin();

    // Receive the response message from the transactional queue.
    responseMsg = transQueue->ReceiveByCorrelationId(id, transaction);

    // Commit the transaction.
    transaction->Commit();
}
catch (Exception^ ex)
{
    // Cancel the transaction.
    transaction->Abort();

    // Propagate the exception.
    throw ex;
}
finally
{
    // Dispose of the transaction object.
    delete transaction;
    transQueue->Close();
    queue->Close(); 
}

// Display the response message's property values.
Console::WriteLine("Message.Label: {0}", responseMsg->Label);
Console::WriteLine("Message.CorrelationId: {0}",
    responseMsg->CorrelationId);


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

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message to the nontransactional queue.
queue.Send(msg, "Example Message Label");

// Get the message's Id property value.
string id = msg.Id;

// Receive the message from the nontransactional queue.
msg = queue.ReceiveById(id, TimeSpan.FromSeconds(10.0));

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

// Create a new message in response to the original message.
Message responseMsg = new Message("Example Response Message Body");

// Set the response message's CorrelationId property value to the Id
// property value of the original message.
responseMsg.CorrelationId = id;

// Send the response message to the transactional queue.
transQueue.Send(responseMsg, "Example Response Message Label",
    MessageQueueTransactionType.Single);

// Simulate doing other work so the message has time to arrive.
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

// Set the transactional queue's MessageReadPropertyFilter property to
// ensure that the response message includes the desired properties.
transQueue.MessageReadPropertyFilter.CorrelationId = true;

// Create a message queuing transaction.
MessageQueueTransaction transaction = new MessageQueueTransaction();

try
{
    // Begin a transaction.
    transaction.Begin();

    // Receive the response message from the transactional queue.
    responseMsg = transQueue.ReceiveByCorrelationId(id, transaction);

    // Commit the transaction.
    transaction.Commit();
}
catch(System.Exception e)
{
    // Cancel the transaction.
    transaction.Abort();

    // Propagate the exception.
    throw e;
}
finally
{
    // Dispose of the transaction object.
    transaction.Dispose();
}

// Display the response message's property values.
Console.WriteLine("Message.Label: {0}", responseMsg.Label);
Console.WriteLine("Message.CorrelationId: {0}",
    responseMsg.CorrelationId);

설명

이 메서드는 지정된 매개 변수와 일치하는 메시지에 CorrelationId 대해 에서 참조 MessageQueue 하는 트랜잭션 큐를 찾습니다correlationId. 매개 변수와 일치하는 correlationID 메시지가 없으면 예외가 throw됩니다. 메시지 큐에서 제거 되 고 정의한 내부 트랜잭션 컨텍스트를 사용 하 여 애플리케이션에 반환 되는 고, 그렇지는 transaction 매개 변수입니다.

속성은 CorrelationId 연결된 응답, 보고서 또는 승인 메시지에 큐에 전송된 메시지를 연결하는 데 사용됩니다.

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

적용 대상

ReceiveByCorrelationId(String)

주어진 상관 관계 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받습니다. 지정된 상관 관계 식별자가 포함된 메시지가 큐에 현재 존재하지 않는 경우에는 바로 예외가 발생합니다.

public:
 System::Messaging::Message ^ ReceiveByCorrelationId(System::String ^ correlationId);

public System.Messaging.Message ReceiveByCorrelationId (string correlationId);

member this.ReceiveByCorrelationId : string -> System.Messaging.Message

Public Function ReceiveByCorrelationId (correlationId As String) As Message

매개 변수

correlationId: String

받을 메시지의 CorrelationId입니다.

반환

Message

전달된 correlationId 매개 변수와 Message가 일치하는 CorrelationId를 반환합니다.

예외

ArgumentNullException

correlationId 매개 변수가 null인 경우

InvalidOperationException

지정된 correlationId의 메시지를 찾을 수 없는 경우

MessageQueueException

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 큐에서 주문을 포함 하는 메시지를 송수신 설정 합니다. 원본 메시지가 도달 하거나이 특히 긍정 승인을 요청 큐에서 검색 합니다.

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

using namespace System;
using namespace System::Messaging;
ref 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 );
      }

   }

   void SendMessage()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

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

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

   String^ ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      myQueue->MessageReadPropertyFilter->CorrelationId = true;
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      String^ returnString = nullptr;
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();

         // Display message information.
         Console::WriteLine( "____________________________________________" );
         Console::WriteLine( "Original message information--" );
         Console::WriteLine( "Body: {0}", myMessage->Body );
         Console::WriteLine( "Id: {0}", myMessage->Id );
         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;
   }

   void ReceiveAcknowledgment( String^ messageId, String^ queuePath )
   {
      bool found = false;
      MessageQueue^ queue = gcnew MessageQueue( queuePath );
      queue->MessageReadPropertyFilter->CorrelationId = true;
      queue->MessageReadPropertyFilter->Acknowledgment = true;
      try
      {
         while ( queue->PeekByCorrelationId( messageId ) != nullptr )
         {
            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: {0}", myAcknowledgmentMessage->CorrelationId );
            Console::WriteLine( "Id: {0}", myAcknowledgmentMessage->Id );
            Console::WriteLine( "Acknowledgment Type: {0}", myAcknowledgmentMessage->Acknowledgment );
            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.
      }

   }

};

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

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

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

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

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

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

Imports System.Messaging


' Provides a container class for the example.

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
      
      
      ' 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
       
      
      
 
      ' 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
      
      
      
 
      ' 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
         
         
                  
         ' 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
 End Class

설명

이 메서드는 지정된 correlationId 매개 변수와 일치하는 메시지에 CorrelationId 대해 에서 참조 MessageQueue 하는 비 트랜잭션 큐를 찾습니다. 매개 변수와 일치하는 correlationID 메시지가 없으면 예외가 throw됩니다. 이 고, 그렇지 메시지 큐에서 제거 되 고 애플리케이션에 반환 됩니다.

속성은 CorrelationId 연결된 응답, 보고서 또는 승인 메시지에 큐에 전송된 메시지를 연결하는 데 사용됩니다.

다른 두 가지 메서드를 사용하면 큐에서 메시지를 받을 수 있습니다. 메서드는 Receive 큐의 첫 번째 메시지를 반환하고 메서드는 ReceiveById(String) 고유 식별자를 지정하여 메시지를 검색합니다.

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

적용 대상

MessageQueue.ReceiveByCorrelationId 메서드

정의

오버로드

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)

매개 변수

반환

예외

예제

설명

추가 정보

적용 대상

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)

매개 변수

반환

예외

예제

설명

추가 정보

적용 대상

ReceiveByCorrelationId(String, TimeSpan)

매개 변수

반환

예외

예제

설명

추가 정보

적용 대상

ReceiveByCorrelationId(String, MessageQueueTransactionType)

매개 변수

반환

예외

예제

설명

추가 정보

적용 대상

ReceiveByCorrelationId(String, MessageQueueTransaction)

매개 변수

반환

예외

예제

설명

추가 정보

적용 대상

ReceiveByCorrelationId(String)

매개 변수

반환

예외

예제

설명

추가 정보

적용 대상

피드백

추가 리소스