Para ver el artículo en inglés, active la casilla Inglés. También puede ver el texto en inglés en una ventana emergente si pasa el puntero del mouse por el texto.
Traducción
Inglés
Esta documentación está archivada y no tiene mantenimiento.

AcknowledgeTypes (Enumeración)

Especifica los tipos de mensajes de confirmación que Message Queue Server devuelve a la aplicación de envío.

Esta enumeración tiene un atributo FlagsAttribute que permite una combinación bit a bit de los valores de miembro.

Espacio de nombres:  System.Messaging
Ensamblado:  System.Messaging (en System.Messaging.dll)

[FlagsAttribute]
public enum AcknowledgeTypes

Nombre de miembroDescripción
PositiveArrivalMáscara que se utiliza para solicitar una confirmación positiva cuando el mensaje original llega a la cola.
PositiveReceiveMáscara que se utiliza para solicitar una confirmación positiva cuando el mensaje original se recupera correctamente de la cola.
NegativeReceiveMáscara que se utiliza para solicitar una confirmación negativa cuando el mensaje original no se recibe de la cola.

El uso del método MessageQueue.Peek no quita un mensaje de la cola, por lo que este tipo de confirmación podría devolverse aunque no se haya leído (Peek) el mensaje. Sólo el método MessageQueue.Receive (o el método MessageQueue.BeginReceive asincrónico asociado) elimina un mensaje de la cola.

NoneMáscara utilizada para solicitar que no se envíe ningún mensaje de confirmación (ya sea positivo o negativo).
NotAcknowledgeReachQueueMáscara que se utiliza para solicitar una confirmación negativa cuando el mensaje original no puede llegar a la cola. Esto sucede cuando expira el tiempo para llegar a la cola o si no se puede autenticar un mensaje.
NotAcknowledgeReceiveMáscara que se utiliza para solicitar una confirmación negativa cuando se produce un error que impide que el mensaje original se reciba desde la cola antes de que expire el tiempo de recepción.
FullReachQueueMáscara que se utiliza para solicitar una confirmación positiva si el mensaje original llega a la cola, o una confirmación negativa si el tiempo para llegar a la cola expira o el mensaje original no se puede autenticar.
FullReceiveMáscara que se utiliza para solicitar una confirmación positiva si el mensaje original se recibe de la cola antes de que el tiempo de recepción expire, o una confirmación negativa en caso contrario.

La clase AcknowledgeTypes proporciona un conjunto de marcadores que se pueden combinar para solicitar una o varias categorías de mensajes de confirmación.

Cuando una aplicación envía un mensaje, puede solicitar que Message Queue Server devuelva mensajes de confirmación que indiquen el éxito o fracaso del mensaje original. Message Queue Server envía dichos mensajes de confirmación a la cola de administración que se especifique. Los tipos de confirmación se pueden dividir en cuatro grupos: confirmaciones de llegada positivas, confirmaciones de lectura positivas, confirmaciones de llegada negativas y confirmaciones de lectura negativas. La solicitud de confirmaciones permite a la aplicación recibir notificación en determinadas circunstancias; por ejemplo, un mensaje que llega a su cola de destino, un mensaje que se está recuperando o un límite de tiempo de espera que impide que un mensaje llegue o sea recuperado de la cola de destino.

Si se utiliza la clase Message para enviar mensajes a una cola, hay que especificar los tipos de confirmaciones que la aplicación deberá recibir en la propiedad AcknowledgeType, así como la cola de administración que recibe los mensajes de confirmación, en la propiedad AdministrationQueue.

Si se utiliza la clase Message para leer los mensajes de confirmación de la cola de administración, la propiedad Acknowledgment de la instancia indicará la condición responsable del mensaje de confirmación, por ejemplo, si ha expirado un tiempo de espera antes de que se leyera el mensaje original de la cola.

En el ejemplo de código siguiente se envía y se recibe un mensaje que contiene una orden que es enviada y recibida de una cola. Esta orden solicita concretamente una confirmación positiva cuando el mensaje original llega o se recupera de la cola.


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

Compatible con: 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.
Mostrar: