MessageQueue.ReceiveByCorrelationId Metoda

Definicja

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 upłynął limit czasu.

ReceiveByCorrelationId(String, TimeSpan)

Odbiera komunikat zgodny z podanym identyfikatorem korelacji (z kolejki innej niż transakcyjna) 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 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.

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 do kontroli.

transactionType
MessageQueueTransactionType

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

Zwraca

Message

Obiekt, którego MessageCorrelationId pasuje do przekazanego parametru correlationId .

Wyjątki

Parametr correlationId to null.

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

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

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

Komunikat z określoną wartością correlationId nie istnieje w kolejce i nie dotarł przed wygaśnięciem 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 wygląda w kolejce, MessageQueue do której odwołuje się komunikat dla komunikatu, którego CorrelationId pasuje do określonego correlationId parametru. Ta metoda zwraca natychmiast, jeśli komunikat o identyfikatorze korelacji określonym przez correlationId parametr znajduje się w kolejce przy użyciu kontekstu transakcji zdefiniowanego transactionType przez parametr . W przeciwnym razie metoda czeka określony okres czasu na nadejście nowego komunikatu. Jeśli nowy komunikat nie zostanie wyświetlony przed wygaśnięciem limitu czasu, zostanie zgłoszony wyjątek.

Parametr timeout nie określa całkowitego czasu działania 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 nowy komunikat, aby sprawdzić, czy jest zgodny z parametrem correlationId . Jeśli tak nie jest, ta metoda rozpoczyna okres przekroczenia limitu czasu i czeka na nadejście kolejnego nowego komunikatu. W związku z tym, jeśli nowe komunikaty będą nadal docierać w okresie przekroczenia limitu czasu, ta metoda może kontynuować 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, którego CorrelationId parametr pasuje do parametru 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 otrzymywać komunikat z kolejki transakcyjnej poza kontekstem transakcji.

Jeśli ta metoda jest wywoływana w celu odebrania komunikatu z kolejki transakcyjnej, komunikat, który zostanie odebrany, 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 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 służy do pobierania komunikatu przez określenie jego unikatowego identyfikatora.

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. Nie ma 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 wycofania, gdyby 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
Komputer lokalny i nazwa formatu bezpośredniego Tak
Komputer zdalny Nie
Nazwa komputera zdalnego i formatu bezpośredniego 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 upłynął limit czasu.

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 do kontroli.

Zwraca

Message

Obiekt, którego MessageCorrelationId pasuje do przekazanego parametru correlationId .

Wyjątki

Parametr correlationId to null.

-lub-

Parametr transaction to null.

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

Komunikat z określoną wartością correlationId nie istnieje w kolejce i nie dotarł przed wygaśnięciem 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 wygląda w kolejce transakcyjnej, MessageQueue do której odwołuje się komunikat dla komunikatu, którego CorrelationId pasuje do określonego correlationId parametru. Ta metoda zwraca natychmiast, jeśli komunikat o identyfikatorze 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 określony okres czasu na nadejście nowego komunikatu. Jeśli nowy komunikat nie zostanie wyświetlony przed wygaśnięciem limitu czasu, zostanie zgłoszony wyjątek.

Parametr timeout nie określa całkowitego czasu działania 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 nowy komunikat, aby sprawdzić, czy jest zgodny z parametrem correlationId . Jeśli tak nie jest, ta metoda rozpoczyna okres przekroczenia limitu czasu i czeka na nadejście kolejnego nowego komunikatu. W związku z tym, jeśli nowe komunikaty będą nadal docierać w okresie przekroczenia limitu czasu, ta metoda może kontynuować 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, którego CorrelationId parametr pasuje do parametru correlationId .

Ponieważ ta metoda jest wywoływana w kolejce transakcyjnej, komunikat, który zostanie odebrany, 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 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 służy do pobierania komunikatu przez określenie jego unikatowego identyfikatora.

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. Nie ma 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 wycofania, gdyby 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
Komputer lokalny i nazwa formatu bezpośredniego Tak
Komputer zdalny Nie
Nazwa komputera zdalnego i formatu bezpośredniego Tak

Zobacz też

Dotyczy

ReceiveByCorrelationId(String, TimeSpan)

Odbiera komunikat zgodny z podanym identyfikatorem korelacji (z kolejki innej niż transakcyjna) 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 do kontroli.

Zwraca

Message

Obiekt, którego MessageCorrelationId pasuje do przekazanego parametru correlationId .

Wyjątki

Parametr correlationId to null.

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

Komunikat z określoną wartością correlationId nie istnieje w kolejce i nie dotarł przed wygaśnięciem 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 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. Ta metoda zwraca natychmiast, jeśli komunikat o identyfikatorze korelacji określonym przez correlationId parametr znajduje się w kolejce. W przeciwnym razie metoda czeka określony okres czasu na nadejście nowego komunikatu. Jeśli nowy komunikat nie zostanie wyświetlony przed wygaśnięciem limitu czasu, zostanie zgłoszony wyjątek.

Parametr timeout nie określa całkowitego czasu działania 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 nowy komunikat, aby sprawdzić, czy jest zgodny z parametrem correlationId . Jeśli tak nie jest, ta metoda rozpoczyna okres przekroczenia limitu czasu i czeka na nadejście kolejnego nowego komunikatu. W związku z tym, jeśli nowe komunikaty będą nadal docierać w okresie przekroczenia limitu czasu, ta metoda może kontynuować 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, którego CorrelationId parametr pasuje do parametru correlationId .

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 służy do pobierania komunikatu przez określenie jego unikatowego identyfikatora.

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

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, którego MessageCorrelationId pasuje do przekazanego parametru correlationId .

Wyjątki

Parametr correlationId to null.

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

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

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 wygląda w kolejce, 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 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 otrzymywać komunikat z kolejki transakcyjnej poza kontekstem transakcji.

Jeśli ta metoda jest wywoływana w celu odebrania komunikatu z kolejki transakcyjnej, komunikat, który zostanie odebrany, 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 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 służy do pobierania komunikatu przez określenie jego unikatowego identyfikatora.

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. Nie ma 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 wycofania, gdyby 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
Komputer lokalny i nazwa formatu bezpośredniego Tak
Komputer zdalny Nie
Nazwa komputera zdalnego i formatu bezpośredniego 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.

Zwraca

Message

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

Wyjątki

Parametr correlationId to null.

-lub-

Parametr transaction to null.

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

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 wygląda w kolejce transakcyjnej, 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 przy użyciu kontekstu transakcji wewnętrznej zdefiniowanej transaction przez parametr .

Ponieważ ta metoda jest wywoływana w kolejce transakcyjnej, komunikat, który zostanie odebrany, 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 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 służy do pobierania komunikatu przez określenie jego unikatowego identyfikatora.

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. Nie ma 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 wycofania, gdyby 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)

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.

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 Message , którego CorrelationId pasuje do przekazanego parametru correlationId .

Wyjątki

Parametr correlationId ma wartość null.

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

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 wyszukuje w kolejce nie 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.

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 pobiera komunikat, określając jego unikatowy identyfikator.

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, więc kolejne wywołania metody zwracają ten sam komunikat, chyba że komunikat o wyższym priorycie zostanie dostarczony do kolejki.

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