AcknowledgeTypes Enumerazione

Definizione

Spazio dei nomi:

System.Messaging

Assembly:

System.Messaging.dll

Specifica i tipi di messaggio di conferma che Accodamento messaggi restituisce all'applicazione mittente.

Questa enumerazione supporta una combinazione bit per bit dei rispettivi valori dei membri.

C#

[System.Flags]
public enum AcknowledgeTypes

Ereditarietà

Object

ValueType

Enum

AcknowledgeTypes

Attributi

FlagsAttribute

Campi

Nome	Valore	Descrizione
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.
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.
NegativeReceive	8	Maschera utilizzata per chiedere una conferma negativa quando non si riesce a ricevere il messaggio originale dalla coda. L'uso del MessageQueue.Peek metodo non rimuove un messaggio dalla coda, pertanto questo tipo di riconoscimento potrebbe essere restituito anche se è stato eseguito il peek del messaggio. Solo il metodo (o il MessageQueue.Receive metodo asincrono MessageQueue.BeginReceive correlato) rimuove un messaggio dalla coda.
None	0	Maschera utilizzata per chiedere che non vengano inviati messaggi di conferma, né positiva, né negativa.
NotAcknowledgeReachQueue	4	Maschera utilizzata per chiedere una conferma negativa quando il messaggio originale non riesce a raggiungere la coda. Questa condizione può verificarsi se il timer di raggiungimento della coda scade o se un messaggio non viene autenticato.
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.
PositiveArrival	1	Maschera utilizzata per chiedere una conferma positiva quando il messaggio originale raggiunge la coda.
PositiveReceive	2	Maschera utilizzata per chiedere una conferma positiva quando il recupero del messaggio originale dalla coda riesce.

Esempio

Nell'esempio di codice seguente viene inviato e ricevuto un messaggio contenente un ordine da e verso una coda. Richiede in particolare un riconoscimento positivo quando il messaggio originale raggiunge o viene recuperato dalla coda.

C#

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

Commenti

La AcknowledgeTypes classe fornisce un set di flag che è possibile combinare per richiedere una o più categorie di messaggi di riconoscimento.

Quando un'applicazione invia un messaggio, può richiedere che Accodamento messaggi restituiscono messaggi che indicano l'esito positivo o negativo del messaggio originale. Accodamento messaggi invia questi messaggi di riconoscimento alla coda di amministrazione specificata. I tipi di riconoscimento possono essere suddivisi in modo ampio in quattro gruppi: riconoscimenti di arrivo positivi, riconoscimenti di lettura positivi, riconoscimenti di arrivo negativi e riconoscimenti di lettura negativi. La richiesta di riconoscimenti consente all'applicazione di ricevere una notifica di determinate occorrenze, ad esempio un messaggio che raggiunge la coda di destinazione, un messaggio recuperato o un timeout che impedisce a un messaggio di raggiungere o recuperare dalla coda di destinazione.

Quando si usa la Message classe per inviare messaggi a una coda, specificare i tipi di riconoscimenti che l'applicazione deve ricevere nella AcknowledgeType proprietà, nonché la coda di amministrazione che riceve i messaggi di riconoscimento nella AdministrationQueue proprietà.

Quando si usa la Message classe per leggere i messaggi di riconoscimento nella coda di amministrazione, la proprietà dell'istanza Acknowledgment indica la condizione responsabile del messaggio di riconoscimento, ad esempio se un timeout è scaduto prima della lettura del messaggio originale dalla coda.

Si applica a

Vedi anche

• Message
• AdministrationQueue
• AcknowledgeType
• Acknowledgment