AcknowledgeTypes AcknowledgeTypes AcknowledgeTypes AcknowledgeTypes Enum

Definición

Especifica los tipos de mensajes de confirmación que Message Queuing devuelve a la aplicación de envío.Specifies the types of acknowledgment message that Message Queuing returns to the sending application.

Esta enumeración tiene el atributo FlagsAttribute, que permite una combinación bit a bit de sus valores de miembro.

public enum class AcknowledgeTypes
[System.Flags]
[System.Serializable]
public enum AcknowledgeTypes
type AcknowledgeTypes = 
Public Enum AcknowledgeTypes
Herencia
AcknowledgeTypesAcknowledgeTypesAcknowledgeTypesAcknowledgeTypes
Atributos

Campos

FullReachQueue FullReachQueue FullReachQueue FullReachQueue 5

Má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.A mask used to request positive acknowledgment if the original message reaches the queue or negative acknowledgment if the time-to-reach-queue timer expires or if the original message cannot be authenticated.

FullReceive FullReceive FullReceive FullReceive 14

Má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.A mask used to request positive acknowledgment if the original message is received from the queue before its time-to-be-received timer expires or negative acknowledgment otherwise.

NegativeReceive NegativeReceive NegativeReceive NegativeReceive 8

Máscara que se utiliza para solicitar una confirmación negativa cuando el mensaje original no se recibe de la cola.A mask used to request a negative acknowledgment when the original message fails to be received from the queue.

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 incluso si se ha visto el mensaje.Using the MessageQueue.Peek method does not remove a message from the queue, so this acknowledgment type could be returned even if you did peek the message. Solo el método MessageQueue.Receive (o el método asincrónico MessageQueue.BeginReceive relacionado) quita un mensaje de la cola.Only the MessageQueue.Receive method (or the related asynchronous MessageQueue.BeginReceive method) removes a message from the queue.

None None None None 0

Máscara utilizada para solicitar que no se envíe ningún mensaje de confirmación (ya sea positivo o negativo).A mask used to request that no acknowledgment messages (positive or negative) be posted.

NotAcknowledgeReachQueue NotAcknowledgeReachQueue NotAcknowledgeReachQueue NotAcknowledgeReachQueue 4

Máscara que se utiliza para solicitar una confirmación negativa cuando el mensaje original no puede llegar a la cola.A mask used to request a negative acknowledgment when the original message cannot reach the queue. Esto sucede cuando expira el tiempo para llegar a la cola o si no se puede autenticar un mensaje.This can happen when the time-to-reach-queue timer expires or if a message cannot be authenticated.

NotAcknowledgeReceive NotAcknowledgeReceive NotAcknowledgeReceive NotAcknowledgeReceive 12

Má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.A mask used to request a negative acknowledgment when an error occurs that prevents the original message from being received from the queue before its time-to-be-received timer expires.

PositiveArrival PositiveArrival PositiveArrival PositiveArrival 1

Máscara que se utiliza para solicitar una confirmación positiva cuando el mensaje original llega a la cola.A mask used to request a positive acknowledgment when the original message reaches the queue.

PositiveReceive PositiveReceive PositiveReceive PositiveReceive 2

Máscara que se utiliza para solicitar una confirmación positiva cuando el mensaje original se recupera correctamente de la cola.A mask used to request a positive acknowledgment when the original message is successfully retrieved from the queue.

Ejemplos

En el ejemplo de código siguiente se envía y recibe un mensaje que contiene un pedido hacia y desde una cola.The following code example sends and receives a message that contains an order to and from a queue. En concreto solicita una confirmación positiva cuando el mensaje original llega o se recupera de la cola.It specifically requests a positive acknowledgment when the original message reaches or is retrieved from the queue.

#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
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 'Main
      
      
      ' 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 'CreateQueue
       
      
      
 
      ' 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 'SendMessage
      
      
      
 
      ' 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 'ReceiveAcknowledgment ' Handle other causes of invalid operation exception.
 End Class 'MyNewQueue

Comentarios

La AcknowledgeTypes clase proporciona un conjunto de marcas que se pueden combinar para solicitar una o varias categorías de mensajes de confirmación.The AcknowledgeTypes class provides a set of flags that you can combine to request one or more categories of acknowledgment messages.

Cuando una aplicación envía un mensaje, puede solicitar que Message Queue Server devuelven mensajes de confirmación que indica el éxito o fracaso del mensaje original.When an application sends a message, it can request that Message Queuing return acknowledgment messages indicating the success or failure of the original message. Message Queue Server envía estos mensajes de confirmación a la cola de administración que especifique.Message Queuing sends these acknowledgment messages to the administration queue you specify. Tipos de confirmación se pueden dividir ampliamente en cuatro grupos: las confirmaciones de llegada positiva, las confirmaciones de lectura positivas, confirmaciones de llegada negativa y confirmaciones negativas de lectura.Acknowledgment types can be divided broadly into four groups: positive arrival acknowledgments, positive read acknowledgments, negative arrival acknowledgments, and negative read acknowledgments. Solicitar confirmaciones permite que la aplicación para recibir la notificación en determinadas circunstancias - por ejemplo, un mensaje que llega a su cola de destino, un mensaje que se va a recuperar o un tiempo de espera impide que un mensaje cuando se alcanza o se recupera desde el cola de destino.Requesting acknowledgments enables your application to receive notification of certain occurrences - for example, a message reaching its destination queue, a message being retrieved, or a time-out preventing a message from reaching or being retrieved from the destination queue.

Cuando se utiliza el Message para enviar mensajes a una cola de clase, especificar los tipos de confirmaciones que la aplicación debe recibir en el AcknowledgeType propiedad, así como la cola de administración que recibe los mensajes de confirmación en el AdministrationQueue propiedad.When you are using the Message class to send messages to a queue, you specify the types of acknowledgments your application should receive in the AcknowledgeType property, as well as the administration queue that receives the acknowledgment messages in the AdministrationQueue property.

Cuando se usa el Message clase para leer mensajes de confirmación de la cola de administración, la instancia Acknowledgment propiedad indica la condición responsable del mensaje de confirmación, por ejemplo, si un tiempo de espera expirado antes del se leyó el mensaje original de la cola.When you use the Message class to read acknowledgment messages in the administration queue, the instance's Acknowledgment property indicates the condition responsible for the acknowledgment message, for example, if a time-out expired before the original message was read from the queue.

Se aplica a

Consulte también: