Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo MessageQueue.ReceiveByCorrelationId (String)

 

Data di pubblicazione: ottobre 2016

Riceve il messaggio che corrisponde all'identificatore di correlazione specificato (da una coda non transazionale) e genera subito un'eccezione se nella coda è attualmente disponibile alcun messaggio con l'identificatore di correlazione specificato.

Spazio dei nomi:   System.Messaging
Assembly:  System.Messaging (in System.Messaging.dll)

public Message ReceiveByCorrelationId(
	string correlationId
)

Parametri

correlationId
Type: System.String

Il CorrelationId del messaggio da ricevere.

Valore restituito

Type: System.Messaging.Message

Il Message cui CorrelationId corrisponde il correlationId passato nel parametro.

Exception Condition
ArgumentNullException

Il valore del parametro correlationId è null.

InvalidOperationException

Il messaggio con l'oggetto specificato correlationId non è stato trovato.

MessageQueueException

Si è verificato un errore quando si accede a un metodo di Accodamento messaggi.

Questo metodo cerca nella coda non transazionale a cui fa riferimento il MessageQueue per un messaggio il cui CorrelationId corrisponde al valore specificato correlationId parametro. Se non viene trovato alcun messaggio corrispondente la correlationID parametro, viene generata un'eccezione. In caso contrario, il messaggio viene rimosso dalla coda e restituito all'applicazione.

Il CorrelationId proprietà viene utilizzata per collegare un messaggio inviato alla coda di messaggi di risposta, report o riconoscimento associati.

Altri due metodi consentono di ricevere messaggi da una coda. Il Receive metodo restituisce il primo messaggio della coda e ReceiveById(String) metodo recupera un messaggio specificando il relativo identificatore univoco.

Per leggere un messaggio con un identificatore di correlazione specificato senza rimuoverlo dalla coda, utilizzare il PeekByCorrelationId(String) metodo. Il PeekByCorrelationId(String) metodo restituisce sempre il primo messaggio della coda, le chiamate successive al metodo restituiscono lo stesso messaggio a meno che un messaggio con priorità più alta arriva nella coda.

Nella tabella seguente indica se questo metodo è disponibile in diverse modalità gruppo di lavoro.

Modalità gruppo di lavoro

Disponibile

Computer locale

Computer locale e il nome di formato direct

Computer remoto

No

Computer remoto e il nome di formato direct

Esempio di codice seguente invia e riceve un messaggio contenente un ordine a e da una coda. In particolare richiede un riconoscimento positivo quando il messaggio originale raggiunge o è recuperato dalla coda.

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

		}
	}
}

.NET Framework
Disponibile da 1.1
Torna all'inizio
Mostra: