Lire en anglais

Partager via


AcknowledgeTypes Énumération

Définition

Spécifie les types de message d’accusé de réception que Message Queuing retourne à l’application émettrice.

Cette énumération prend en charge une combinaison au niveau du bit de ses valeurs membres.

C#
[System.Flags]
public enum AcknowledgeTypes
Héritage
AcknowledgeTypes
Attributs

Champs

Nom Valeur Description
FullReachQueue 5

Masque utilisé pour demander un accusé de réception positif si le message d’origine atteint la file d’attente ou un accusé de réception négatif si le délai d’entrée dans la file d’attente a expiré ou si le message d’origine ne peut pas être authentifié.

FullReceive 14

Masque utilisé pour demander un accusé de réception positif si le message d’origine est reçu à partir de la file d’attente avant expiration de son délai de réception ou un accusé de réception négatif dans les autres cas.

NegativeReceive 8

Masque utilisé pour demander un accusé de réception négatif quand la réception du message d’origine à partir de la file d’attente échoue.

L’utilisation de la MessageQueue.Peek méthode ne supprime pas un message de la file d’attente, de sorte que ce type d’accusé de réception peut être retourné même si vous avez vu le message. Seule la MessageQueue.Receive méthode (ou la méthode asynchrone MessageQueue.BeginReceive associée) supprime un message de la file d’attente.

None 0

Masque utilisé pour demander de n’envoyer aucun message d’accusé de réception (positif ou négatif).

NotAcknowledgeReachQueue 4

Masque utilisé pour demander un accusé de réception négatif quand le message d’origine ne peut pas atteindre la file d’attente. Cela peut se produire quand le délai d’entrée dans la file d’attente expire ou qu’un message ne peut pas être authentifié.

NotAcknowledgeReceive 12

Masque utilisé pour demander un accusé de réception négatif quand une erreur se produit et empêche la réception du message d’origine à partir de la file d’attente avant expiration de son délai de réception.

PositiveArrival 1

Masque utilisé pour demander un accusé de réception positif quand le message d’origine atteint la file d’attente.

PositiveReceive 2

Masque utilisé pour demander un accusé de réception positif quand le message d’origine est récupéré de la file d’attente.

Exemples

L’exemple de code suivant envoie et reçoit un message qui contient une commande vers et depuis une file d’attente. Il demande spécifiquement un accusé de réception positif lorsque le message d’origine atteint ou est récupéré à partir de la file d’attente.

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

Remarques

La AcknowledgeTypes classe fournit un ensemble d’indicateurs que vous pouvez combiner pour demander une ou plusieurs catégories de messages d’accusé de réception.

Lorsqu’une application envoie un message, elle peut demander à Message Queuing de renvoyer des messages d’accusé de réception indiquant la réussite ou l’échec du message d’origine. Message Queuing envoie ces messages d’accusé de réception à la file d’attente d’administration que vous spécifiez. Les types d’accusés de réception peuvent être répartis en quatre groupes : accusés d’arrivée positifs, accusés de réception de lecture positifs, accusés d’arrivée négatifs et accusés de réception de lecture négatifs. La demande d’accusés de réception permet à votre application de recevoir une notification de certaines occurrences, par exemple, un message atteignant sa file d’attente de destination, un message en cours de récupération ou un délai d’attente empêchant un message d’atteindre ou d’être récupéré à partir de la file d’attente de destination.

Lorsque vous utilisez la Message classe pour envoyer des messages à une file d’attente, vous spécifiez les types d’accusés de réception que votre application doit recevoir dans la AcknowledgeType propriété , ainsi que la file d’attente d’administration qui reçoit les messages d’accusé de réception dans la AdministrationQueue propriété .

Lorsque vous utilisez la Message classe pour lire les messages d’accusé de réception dans la file d’attente d’administration, la propriété de Acknowledgment l’instance indique la condition responsable du message d’accusé de réception, par exemple, si un délai d’expiration a expiré avant que le message d’origine ait été lu à partir de la file d’attente.

S’applique à

Produit Versions
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1

Voir aussi