AcknowledgeTypes AcknowledgeTypes AcknowledgeTypes AcknowledgeTypes Enum

Definizione

Specifica i tipi di messaggio di conferma che Accodamento messaggi restituisce all'applicazione mittente.Specifies the types of acknowledgment message that Message Queuing returns to the sending application.

Questa enumerazione ha un attributo FlagsAttribute che consente una combinazione bit per bit dei valori del relativo membro.

public enum class AcknowledgeTypes
[System.Flags]
[System.Serializable]
public enum AcknowledgeTypes
type AcknowledgeTypes = 
Public Enum AcknowledgeTypes
Ereditarietà
AcknowledgeTypesAcknowledgeTypesAcknowledgeTypesAcknowledgeTypes
Attributi

Campi

FullReachQueue FullReachQueue FullReachQueue FullReachQueue 5

Maschera utilizzata per richiedere una conferma positiva se il messaggio originale raggiunge la coda oppure una conferma negativa se il timer di raggiungimento della coda scade o se è impossibile autenticare il messaggio originale.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

Maschera utilizzata per chiedere una conferma positiva se il messaggio originale viene ricevuto dalla coda prima dello scadere del timer di ricezione o, in caso contrario, per chiedere una conferma negativa.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

Maschera utilizzata per chiedere una conferma negativa quando non si riesce a ricevere il messaggio originale dalla coda.A mask used to request a negative acknowledgment when the original message fails to be received from the queue.

Se si usa il metodo MessageQueue.Peek, il messaggio non viene rimosso dalla coda, quindi è possibile che questo tipo di riconoscimento venga restituito anche se il messaggio è stato letto.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 il metodo MessageQueue.Receive, o il metodo asincrono MessageQueue.BeginReceive correlato, rimuove un messaggio dalla coda.Only the MessageQueue.Receive method (or the related asynchronous MessageQueue.BeginReceive method) removes a message from the queue.

None None None None 0

Maschera utilizzata per chiedere che non vengano inviati messaggi di conferma, né positiva, né negativa.A mask used to request that no acknowledgment messages (positive or negative) be posted.

NotAcknowledgeReachQueue NotAcknowledgeReachQueue NotAcknowledgeReachQueue NotAcknowledgeReachQueue 4

Maschera utilizzata per chiedere una conferma negativa quando il messaggio originale non riesce a raggiungere la coda.A mask used to request a negative acknowledgment when the original message cannot reach the queue. Questa condizione può verificarsi se il timer di raggiungimento della coda scade o se un messaggio non viene autenticato.This can happen when the time-to-reach-queue timer expires or if a message cannot be authenticated.

NotAcknowledgeReceive NotAcknowledgeReceive NotAcknowledgeReceive NotAcknowledgeReceive 12

Maschera utilizzata per chiedere una conferma negativa quando un errore impedisce la ricezione del messaggio originale dalla coda prima dello scadere del suo timer di ricezione.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

Maschera utilizzata per chiedere una conferma positiva quando il messaggio originale raggiunge la coda.A mask used to request a positive acknowledgment when the original message reaches the queue.

PositiveReceive PositiveReceive PositiveReceive PositiveReceive 2

Maschera utilizzata per chiedere una conferma positiva quando il recupero del messaggio originale dalla coda riesce.A mask used to request a positive acknowledgment when the original message is successfully retrieved from the queue.

Esempi

Esempio di codice seguente invia e riceve un messaggio contenente un ordine a e da una coda.The following code example sends and receives a message that contains an order to and from a queue. In particolare richiede una conferma positiva quando il messaggio originale raggiunge o viene recuperato dalla coda.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

Commenti

Il AcknowledgeTypes classe fornisce un set di flag che è possibile combinare per richiedere una o più categorie di messaggi di riconoscimento.The AcknowledgeTypes class provides a set of flags that you can combine to request one or more categories of acknowledgment messages.

Quando un'applicazione invia un messaggio, è possibile richiedere che il servizio Accodamento messaggi restituisce i messaggi di riconoscimento che indica l'esito positivo o negativo del messaggio originale.When an application sends a message, it can request that Message Queuing return acknowledgment messages indicating the success or failure of the original message. Accodamento messaggi invia questi messaggi di riconoscimento per la coda di amministrazione specificata.Message Queuing sends these acknowledgment messages to the administration queue you specify. Tipi di riconoscimento possono essere ampiamente suddivisi in quattro gruppi: acknowledgment positivo di arrivo, riconoscimenti positivi di lettura, i riconoscimenti di conferma negativo di arrivo e riconoscimenti negativi di lettura.Acknowledgment types can be divided broadly into four groups: positive arrival acknowledgments, positive read acknowledgments, negative arrival acknowledgments, and negative read acknowledgments. La richiesta di riconoscimenti consente all'applicazione di ricevere la notifica di determinati eventi, ad esempio, un messaggio ha raggiunto la coda di destinazione, il recupero di un messaggio o un timeout che impedisce che un messaggio di raggiungimento o il recupero dal coda di destinazione.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.

Quando si usa la Message classe per l'invio di messaggi a una coda, specificare i tipi di riconoscimenti dell'applicazione deve ricevere nel AcknowledgeType proprietà, nonché la coda di amministrazione che riceve i messaggi di riconoscimento nel AdministrationQueue proprietà.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.

Quando si usa la Message per leggere i messaggi di riconoscimento nella coda di amministrazione, l'istanza classe Acknowledgment proprietà indica la condizione responsabile per il messaggio di riconoscimento, ad esempio, se il timeout è scaduto prima di messaggio originale è stato letto dalla coda.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.

Si applica a

Vedi anche