Export (0) Print
Expand All
Expand Minimize
This topic has not yet been rated - Rate this topic

Acknowledgment Enumeration

Specifies the result of an attempted message delivery.

Namespace:  System.Messaging
Assembly:  System.Messaging (in System.Messaging.dll)
public enum class Acknowledgment
Member nameDescription
AccessDeniedA negative arrival acknowledgment indicating that the sending application does not have the necessary rights to send a message to the destination queue.
BadDestinationQueueA negative arrival acknowledgment indicating that the destination queue is not available to the sending application.
BadEncryptionA negative arrival acknowledgment indicating that the destination queue manager could not decrypt a private message.
BadSignatureA negative arrival acknowledgment indicating that the original message's digital signature is not valid and could not be authenticated by Message Queuing.
CouldNotEncryptA negative arrival acknowledgment indicating that the source queue manager could not encrypt a private message.
HopCountExceededA negative arrival acknowledgment indicating that the original message's hop count (which indicates the number of intermediate servers) was exceeded.

The maximum hop count, 15, is set by Message Queuing and is immutable.

NoneThe message is not an acknowledgment message.
NotTransactionalMessageA negative arrival acknowledgment indicating that a non-transactional message was sent to a transactional queue.
NotTransactionalQueueA negative arrival acknowledgment indicating that a transactional message was sent to a non-transactional queue.
PurgedA negative arrival acknowledgment indicating that the message was purged before reaching its destination queue.
QueueDeletedA negative read acknowledgment indicating that the queue was deleted before the message could be read.
QueueExceedMaximumSizeA negative arrival acknowledgment indicating that the original message was not delivered because its destination queue is full.
QueuePurgedA negative read acknowledgment indicating that the queue was purged before the message could be read.
ReachQueueA positive arrival acknowledgment indicating that the original message reached its destination queue.
ReachQueueTimeoutA negative arrival acknowledgment indicating that the time-to-reach-queue or time-to-be-received timer expired before the original message could reach the destination queue.
ReceiveA positive read acknowledgment indicating that the original message was received by the receiving application.
ReceiveTimeoutA negative read acknowledgment indicating that the original message was not received from the queue before its time-to-be-received timer expired.

The Acknowledgment class defines the types of acknowledgment messages that Message Queuing posts in the administration queue and the conditions that cause an acknowledgment message to be sent. Acknowledgment types can be divided broadly into four groups: positive arrival acknowledgments, positive read acknowledgments, negative arrival acknowledgments, and negative read acknowledgments.

The administration queue associated with message is specified in the Message::AdministrationQueue property.

Message Queuing sets the Message::Acknowledgment property to one of the Acknowledgment enumeration values when it creates an acknowledgment message. The Message::Acknowledgment property value is typically meaningful only when the instance refers to a system-sent acknowledgment message. Reading the Message::Acknowledgment property for a message other than an acknowledgment message throws an exception.

Message Queuing does not send an acknowledgment message unless the sending application requests that it do so. Your application makes this request by setting the appropriate value for the Message::AcknowledgeType property. Message Queuing sends all acknowledgment messages to the administration queue specified in the AdministrationQueue property of the original Message.

The following code example sends and receives a message containing an order to and from a queue. 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;
}

.NET Framework

Supported in: 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role supported with SP1 or later; Itanium not supported)

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft. All rights reserved.