Export (0) Print
Expand All

Message.AcknowledgeType Property

Gets or sets the type of acknowledgment message to be returned to the sending application.

Namespace:  System.Messaging
Assembly:  System.Messaging (in System.Messaging.dll)

[MessagingDescriptionAttribute("MsgAcknowledgeType")]
public AcknowledgeTypes AcknowledgeType { get; set; }

Property Value

Type: System.Messaging.AcknowledgeTypes
One of the AcknowledgeTypes values, which represent both the types of acknowledgment messages the system posts in the administration queue and the conditions under which acknowledgments are returned to the sending application. The default is None.

ExceptionCondition
InvalidOperationException

The message is filtered to ignore the AcknowledgeType property.

The AcknowledgeType property specifies the type of acknowledgment messages requested by the sending application. Set the AcknowledgeType property before sending the message to request 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.

Message Queuing returns notification by sending acknowledgment messages to the AdministrationQueue property specified by the original message. An acknowledgment message's Acknowledgment property indicates the type of acknowledgment that it represents. For example, if an acknowledgment message was sent because a message did not reach the destination before the TimeToReachQueue interval expired, the Acknowledgment property of the acknowledgment message would contain the value ReachQueueTimeout.

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

		}
	}
}
#using <mscorlib.dll>
#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

__gc 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);
		}

	}

public:
	void SendMessage() 
	{

		// Connect to a queue on the local computer.
		MessageQueue* myQueue = new MessageQueue(S".\\myQueue");

		// Create a new message.
		Message* myMessage = new Message(S"Original Message");
		myMessage->AdministrationQueue = new MessageQueue(S".\\myAdministrationQueue");
		myMessage->AcknowledgeType = (AcknowledgeTypes)(AcknowledgeTypes::PositiveReceive | AcknowledgeTypes::PositiveArrival);

		// Send the Order to the queue.
		myQueue->Send(myMessage);

		return;
	}



public:
	String* ReceiveMessage() 
	{
		// Connect to the a queue on the local computer.
		MessageQueue* myQueue = new MessageQueue(S".\\myQueue");

		myQueue->MessageReadPropertyFilter->CorrelationId = true;

		Type* p __gc[] = new Type*[1];
		p[0] =	__typeof(String);
		myQueue->Formatter = new XmlMessageFormatter( p );

		String* returnString = 0;

		try 
		{
			// Receive and format the message. 
			Message* myMessage = myQueue->Receive(); 

			// Display message information.
			Console::WriteLine(S"____________________________________________");
			Console::WriteLine(S"Original message information--");
			Console::WriteLine(S"Body: {0}", myMessage->Body);
			Console::WriteLine(S"Id: {0}", myMessage->Id);
			Console::WriteLine(S"____________________________________________");

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

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) != 0) 
			{
				Message* myAcknowledgmentMessage = queue->ReceiveByCorrelationId(messageId);

				// Output acknowledgment message information. The correlation Id is identical
				// to the id of the original message.
				Console::WriteLine(S"Acknowledgment Message Information--");
				Console::WriteLine(S"Correlation Id: {0}", myAcknowledgmentMessage->CorrelationId);
				Console::WriteLine(S"Id: {0}", myAcknowledgmentMessage->Id);
				Console::WriteLine(S"Acknowledgment Type: {0}", __box(myAcknowledgmentMessage->Acknowledgment));
				Console::WriteLine(S"____________________________________________");

				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 = new MyNewQueue();

	// Create new queues.
	MyNewQueue::CreateQueue(S".\\myQueue");
	MyNewQueue::CreateQueue(S".\\myAdministrationQueue");

	// Send messages to a queue.
	myNewQueue->SendMessage();

	// Receive messages from a queue.
	String* messageId = myNewQueue->ReceiveMessage(); 

	// Receive acknowledgment message.
	if (messageId != 0) 
	{
		myNewQueue->ReceiveAcknowledgment(messageId, S".\\myAdministrationQueue");
	}

	return 0;
}

Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC

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

.NET Framework

Supported in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 3.5, 2.0

Community Additions

ADD
Show:
© 2014 Microsoft