MessageQueue.ReceiveByCorrelationId Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Messaging

Zestaw:: System.Messaging.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Odbiera komunikat zgodny z danym identyfikatorem korelacji.

Przeciążenia

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)	Odbiera komunikat zgodny z danym identyfikatorem korelacji i czeka, aż komunikat o określonym identyfikatorze korelacji będzie dostępny w kolejce lub upłynął limit czasu.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)	Odbiera komunikat zgodny z danym identyfikatorem korelacji (z kolejki transakcyjnej) i czeka, aż komunikat o określonym identyfikatorze korelacji będzie dostępny w kolejce lub limit czasu wygasa.
ReceiveByCorrelationId(String, TimeSpan)	Odbiera komunikat zgodny z danym identyfikatorem korelacji (z kolejki nie transakcyjnej) i czeka, aż komunikat o określonym identyfikatorze korelacji będzie dostępny w kolejce lub upłynął limit czasu.
ReceiveByCorrelationId(String, MessageQueueTransactionType)	Odbiera komunikat zgodny z danym identyfikatorem korelacji i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.
ReceiveByCorrelationId(String, MessageQueueTransaction)	Odbiera komunikat zgodny z danym identyfikatorem korelacji (z kolejki transakcyjnej) i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.
ReceiveByCorrelationId(String)	Odbiera komunikat zgodny z danym identyfikatorem korelacji (z kolejki nie transakcyjnej) i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)

Odbiera komunikat zgodny z danym identyfikatorem korelacji i czeka, aż komunikat o określonym identyfikatorze korelacji będzie dostępny w kolejce lub upłynął limit czasu.

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

Parametry

correlationId: String

Komunikat CorrelationId do odebrania.

timeout: TimeSpan

Element TimeSpan wskazujący czas oczekiwania na udostępnienie nowej wiadomości na potrzeby inspekcji.

transactionType: MessageQueueTransactionType

MessageQueueTransactionType Jedna z wartości opisujących typ kontekstu transakcji do skojarzenia z komunikatem.

Zwraca

Message

Obiekt Message , którego CorrelationId pasuje do przekazanego parametru correlationId .

Wyjątki

ArgumentNullException

Parametr correlationId ma wartość null.

InvalidOperationException

Nie można odnaleźć komunikatu o określonej wartości correlationId .

ArgumentException

Wartość określona dla parametru timeout jest nieprawidłowa, prawdopodobnie timeout jest mniejsza lub większa niż Zero InfiniteTimeout.

InvalidEnumArgumentException

Parametr transactionType nie jest jednym z MessageQueueTransactionType elementów członkowskich.

MessageQueueException

Komunikat z określonym correlationId elementem nie istnieje w kolejce i nie został dostarczony przed upływem limitu czasu.

-lub-

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

W poniższym przykładzie kodu pokazano użycie metody 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);

Uwagi

Ta metoda wyszukuje w kolejce, do której odwołuje się MessageQueue element dla komunikatu, którego CorrelationId pasuje do określonego correlationId parametru. Ta metoda zwraca natychmiast, jeśli komunikat z identyfikatorem korelacji określonym przez correlationId parametr znajduje się w kolejce, przy użyciu kontekstu transakcji zdefiniowanego transactionType przez parametr . W przeciwnym razie metoda czeka na nadejście nowego komunikatu. Jeśli nowy komunikat nie pojawi się przed upływem limitu czasu, zostanie zgłoszony wyjątek.

Parametr timeout nie określa całkowitego czasu wykonywania dla tej metody. Zamiast tego określa czas oczekiwania na nadejście nowego komunikatu do kolejki. Za każdym razem, gdy pojawi się nowy komunikat, ta metoda analizuje CorrelationId komunikat, aby sprawdzić, czy jest on zgodny z parametrem correlationId . Jeśli nie, ta metoda rozpoczyna limit czasu i czeka na nadejście kolejnego nowego komunikatu. W związku z tym, jeśli nowe komunikaty będą nadal docierać w okresie limitu czasu, jest możliwe, aby ta metoda kontynuowała działanie na czas nieokreślony, do momentu wygaśnięcia limitu czasu bez nadejścia nowych komunikatów lub do momentu nadejścia komunikatu zgodnego CorrelationId z parametrem correlationId . Określ Automatic parametr , transactionType jeśli istnieje już zewnętrzny kontekst transakcji dołączony do wątku, którego chcesz użyć do odbierania komunikatu. Określ Single , czy chcesz otrzymywać komunikat jako pojedynczą transakcję wewnętrzną. Możesz określić None , czy chcesz odbierać komunikat z kolejki transakcyjnej poza kontekstem transakcji.

Jeśli ta metoda jest wywoływana w celu odbierania komunikatu z kolejki transakcyjnej, odebrany komunikat zostanie zwrócony do kolejki, jeśli transakcja zostanie przerwana. Komunikat nie zostanie trwale usunięty z kolejki, dopóki transakcja nie zostanie zatwierdzona.

Właściwość CorrelationId służy do powiązania komunikatu wysyłanego do kolejki do skojarzonej odpowiedzi, raportu lub komunikatów potwierdzenia.

Dwie inne metody umożliwiają odbieranie komunikatów z kolejki. Metoda Receive zwraca pierwszy komunikat w kolejce, a ReceiveById(String) metoda jest używana do pobierania komunikatu przez określenie jego unikatowego identyfikatora.

Aby odczytać komunikat z określonym identyfikatorem korelacji bez usuwania go z kolejki, użyj PeekByCorrelationId(String) metody . Metoda PeekByCorrelationId(String) zawsze zwraca pierwszy komunikat w kolejce, dlatego kolejne wywołania metody zwracają ten sam komunikat, chyba że komunikat o wyższym priorytcie pojawi się w kolejce. Brak kontekstu transakcji skojarzonego z komunikatem zwróconym przez wywołanie metody PeekByCorrelationId(String). Ponieważ PeekByCorrelationId(String) nie usuwa żadnych komunikatów w kolejce, nie byłoby nic do wycofywania, jeśli transakcja została przerwana.

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Nazwa komputera lokalnego i bezpośredniego formatu	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i bezpośredniego formatu	Tak

Zobacz też

Dotyczy

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)

Odbiera komunikat zgodny z danym identyfikatorem korelacji (z kolejki transakcyjnej) i czeka, aż komunikat o określonym identyfikatorze korelacji będzie dostępny w kolejce lub limit czasu wygasa.

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

Parametry

correlationId: String

Komunikat CorrelationId do odebrania.

timeout: TimeSpan

Element TimeSpan wskazujący czas oczekiwania na udostępnienie nowej wiadomości na potrzeby inspekcji.

transaction: MessageQueueTransaction

Obiekt MessageQueueTransaction.

Zwraca

Message

Obiekt Message , którego CorrelationId pasuje do przekazanego parametru correlationId .

Wyjątki

ArgumentNullException

Parametr correlationId ma wartość null.

-lub-

Parametr transaction ma wartość null.

ArgumentException

Wartość określona dla parametru timeout jest nieprawidłowa, prawdopodobnie timeout jest mniejsza lub większa niż Zero InfiniteTimeout.

MessageQueueException

Komunikat z określonym correlationId elementem nie istnieje w kolejce i nie został dostarczony przed upływem limitu czasu.

-lub-

Kolejka nie jest transakcyjna.

-lub-

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

W poniższym przykładzie kodu pokazano użycie metody 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);

Uwagi

Ta metoda szuka w kolejce transakcyjnej, do której odwołuje się MessageQueue element dla komunikatu, którego CorrelationId pasuje do określonego correlationId parametru. Ta metoda zwraca natychmiast, jeśli komunikat z identyfikatorem korelacji określonym przez correlationId parametr znajduje się w kolejce, przy użyciu wewnętrznego kontekstu transakcji zdefiniowanego transaction przez parametr . W przeciwnym razie metoda czeka na nadejście nowego komunikatu. Jeśli nowy komunikat nie pojawi się przed upływem limitu czasu, zostanie zgłoszony wyjątek.

Ponieważ ta metoda jest wywoływana w kolejce transakcyjnej, odebrany komunikat zostanie zwrócony do kolejki, jeśli transakcja zostanie przerwana. Komunikat nie zostanie trwale usunięty z kolejki, dopóki transakcja nie zostanie zatwierdzona.

Właściwość CorrelationId służy do powiązania komunikatu wysyłanego do kolejki do skojarzonej odpowiedzi, raportu lub komunikatów potwierdzenia.

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Nazwa komputera lokalnego i bezpośredniego formatu	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i bezpośredniego formatu	Tak

Zobacz też

Dotyczy

ReceiveByCorrelationId(String, TimeSpan)

Odbiera komunikat zgodny z danym identyfikatorem korelacji (z kolejki nie transakcyjnej) i czeka, aż komunikat o określonym identyfikatorze korelacji będzie dostępny w kolejce lub upłynął limit czasu.

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

Parametry

correlationId: String

Komunikat CorrelationId do odebrania.

timeout: TimeSpan

Element TimeSpan wskazujący czas oczekiwania na udostępnienie nowej wiadomości na potrzeby inspekcji.

Zwraca

Message

Obiekt Message , którego CorrelationId pasuje do przekazanego parametru correlationId .

Wyjątki

ArgumentNullException

Parametr correlationId ma wartość null.

ArgumentException

Wartość określona dla parametru timeout jest nieprawidłowa, prawdopodobnie timeout jest mniejsza lub większa niż Zero InfiniteTimeout.

MessageQueueException

Komunikat z określonym correlationId elementem nie istnieje w kolejce i nie został dostarczony przed upływem limitu czasu.

-lub-

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

W poniższym przykładzie kodu pokazano użycie metody 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);

Uwagi

Ta metoda wyszukuje w kolejce nie transakcyjnej, do której odwołuje się MessageQueue element dla komunikatu, którego CorrelationId pasuje do określonego correlationId parametru. Ta metoda zwraca natychmiast, jeśli komunikat z identyfikatorem korelacji określonym przez correlationId parametr znajduje się w kolejce. W przeciwnym razie metoda czeka na nadejście nowego komunikatu. Jeśli nowy komunikat nie pojawi się przed upływem limitu czasu, zostanie zgłoszony wyjątek.

Właściwość CorrelationId służy do powiązania komunikatu wysyłanego do kolejki do skojarzonej odpowiedzi, raportu lub komunikatów potwierdzenia.

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Nazwa komputera lokalnego i bezpośredniego formatu	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i bezpośredniego formatu	Tak

Zobacz też

Dotyczy

ReceiveByCorrelationId(String, MessageQueueTransactionType)

Odbiera komunikat zgodny z danym identyfikatorem korelacji i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.

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

Parametry

correlationId: String

Komunikat CorrelationId do odebrania.

transactionType: MessageQueueTransactionType

MessageQueueTransactionType Jedna z wartości opisujących typ kontekstu transakcji do skojarzenia z komunikatem.

Zwraca

Message

Obiekt Message , którego CorrelationId pasuje do przekazanego parametru correlationId .

Wyjątki

ArgumentNullException

Parametr correlationId ma wartość null.

InvalidOperationException

Nie można odnaleźć komunikatu o określonej wartości correlationId .

InvalidEnumArgumentException

Parametr transactionType nie jest jednym z MessageQueueTransactionType elementów członkowskich.

MessageQueueException

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

W poniższym przykładzie kodu pokazano użycie metody 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);

Uwagi

Ta metoda wyszukuje w kolejce, do której odwołuje się MessageQueue element dla komunikatu, którego CorrelationId pasuje do określonego correlationId parametru. Jeśli nie zostanie znaleziony komunikat zgodny z parametrem correlationID , zostanie zgłoszony wyjątek. W przeciwnym razie komunikat zostanie usunięty z kolejki i zwrócony do aplikacji przy użyciu kontekstu transakcji zdefiniowanego transactionType przez parametr .

Określ Automatic parametr , transactionType jeśli istnieje już zewnętrzny kontekst transakcji dołączony do wątku, którego chcesz użyć do odbierania komunikatu. Określ Single , czy chcesz otrzymywać komunikat jako pojedynczą transakcję wewnętrzną. Możesz określić None , czy chcesz odbierać komunikat z kolejki transakcyjnej poza kontekstem transakcji.

Właściwość CorrelationId służy do powiązania komunikatu wysyłanego do kolejki do skojarzonej odpowiedzi, raportu lub komunikatów potwierdzenia.

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Nazwa komputera lokalnego i bezpośredniego formatu	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i bezpośredniego formatu	Tak

Zobacz też

Dotyczy

ReceiveByCorrelationId(String, MessageQueueTransaction)

Odbiera komunikat zgodny z danym identyfikatorem korelacji (z kolejki transakcyjnej) i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.

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

Parametry

correlationId: String

Komunikat CorrelationId do odebrania.

transaction: MessageQueueTransaction

Obiekt MessageQueueTransaction.

Zwraca

Message

Obiekt, którego Message CorrelationId pasuje do przekazanego parametru correlationId .

Wyjątki

ArgumentNullException

Parametr correlationId ma wartość null.

-lub-

Parametr transaction ma wartość null.

InvalidOperationException

Nie można odnaleźć komunikatu o określonej wartości correlationId .

MessageQueueException

Kolejka nie jest transakcyjna.

-lub-

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

W poniższym przykładzie kodu pokazano użycie metody 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);

Uwagi

Ta metoda szuka w kolejce transakcyjnej, do której odwołuje się MessageQueue element dla komunikatu, którego CorrelationId pasuje do określonego correlationId parametru. Jeśli nie zostanie znaleziony komunikat zgodny z parametrem correlationID , zostanie zgłoszony wyjątek. W przeciwnym razie komunikat zostanie usunięty z kolejki i zwrócony do aplikacji przy użyciu wewnętrznego kontekstu transakcji zdefiniowanego transaction przez parametr .

Właściwość CorrelationId służy do powiązania komunikatu wysyłanego do kolejki do skojarzonej odpowiedzi, raportu lub komunikatów potwierdzenia.

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Komputer lokalny i nazwa formatu bezpośredniego	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i formatu bezpośredniego	Tak

Zobacz też

Dotyczy

ReceiveByCorrelationId(String)

Odbiera komunikat zgodny z podanym identyfikatorem korelacji (z kolejki innej niż transakcyjna) i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.

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

Parametry

correlationId: String

Komunikat CorrelationId do odebrania.

Zwraca

Message

Obiekt, którego Message CorrelationId pasuje do przekazanego parametru correlationId .

Wyjątki

ArgumentNullException

Parametr correlationId to null.

InvalidOperationException

Nie można odnaleźć komunikatu z określonym correlationId .

MessageQueueException

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu wysyła i odbiera komunikat zawierający zamówienie do i z kolejki. W szczególności żąda pozytywnego potwierdzenia, gdy oryginalny komunikat osiągnie lub zostanie pobrany z kolejki.

#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

Uwagi

Ta metoda wygląda w kolejce innej niż transakcyjna, MessageQueue do której odwołuje się komunikat dla komunikatu, którego CorrelationId pasuje do określonego correlationId parametru. Jeśli nie znaleziono komunikatu zgodnego z parametrem correlationID , zgłaszany jest wyjątek. W przeciwnym razie komunikat zostanie usunięty z kolejki i zwrócony do aplikacji.

Właściwość CorrelationId jest używana do powiązania komunikatu wysyłanego do kolejki do skojarzonej odpowiedzi, raportu lub komunikatów potwierdzenia.

Dwie inne metody umożliwiają odbieranie komunikatów z kolejki. Metoda Receive zwraca pierwszy komunikat w kolejce, a ReceiveById(String) metoda pobiera komunikat, określając jego unikatowy identyfikator.

Aby odczytać komunikat z określonym identyfikatorem korelacji bez usunięcia go z kolejki, użyj PeekByCorrelationId(String) metody . Metoda PeekByCorrelationId(String) zawsze zwraca pierwszy komunikat w kolejce, więc kolejne wywołania metody zwracają ten sam komunikat, chyba że w kolejce pojawi się komunikat o wyższym priorytcie.

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Komputer lokalny i nazwa formatu bezpośredniego	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i formatu bezpośredniego	Tak

Zobacz też

Dotyczy

MessageQueue.ReceiveByCorrelationId Metoda

Definicja

Przeciążenia

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

ReceiveByCorrelationId(String, TimeSpan)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

ReceiveByCorrelationId(String, MessageQueueTransactionType)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

ReceiveByCorrelationId(String, MessageQueueTransaction)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

ReceiveByCorrelationId(String)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Opinia

Dodatkowe zasoby