MessageQueue.PeekByCorrelationId Méthode

Définition

Espace de noms:

System.Messaging

Assembly:

System.Messaging.dll

Lit un message qui correspond à un identificateur de corrélation donné.

Surcharges

PeekByCorrelationId(String)	Lit le message qui correspond à l'identificateur de corrélation donné et lève immédiatement une exception si la file ne contient aucun message correspondant à cet identificateur.
PeekByCorrelationId(String, TimeSpan)	Lit le message qui correspond à l'identificateur de corrélation donné puis attend qu'un message ayant l'identificateur spécifié soit disponible dans la file d'attente, ou que le délai d'attente expire.

PeekByCorrelationId(String)

Lit le message qui correspond à l'identificateur de corrélation donné et lève immédiatement une exception si la file ne contient aucun message correspondant à cet identificateur.

C#

public System.Messaging.Message PeekByCorrelationId (string correlationId);

Paramètres

correlationId

String

Propriété CorrelationId du message à lire.

Retours

Message

Message dont la propriété CorrelationId correspond au paramètre correlationId passé.

Exceptions

ArgumentNullException

Le paramètre correlationId a la valeur null.

InvalidOperationException

Impossible de trouver le message avec le paramètre correlationId spécifié.

MessageQueueException

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

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

Cette méthode recherche dans la file d’attente référencée par le MessageQueue pour un message dont CorrelationId le paramètre correspond au paramètre spécifié correlationId . Si aucun message correspondant au correlationID paramètre n’est trouvé, une exception est levée.

La CorrelationId propriété est utilisée pour lier un message envoyé à la file d’attente aux messages de réponse, de rapport ou d’accusé de réception associés.

Deux autres méthodes vous permettent d’aperçu des messages dans une file d’attente. La Peek méthode retourne le premier message de la file d’attente, et la PeekById(String) méthode est utilisée pour récupérer un message en spécifiant son identificateur unique.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

• CorrelationId
• Peek()
• BeginPeek()

PeekByCorrelationId(String, TimeSpan)

Lit le message qui correspond à l'identificateur de corrélation donné puis attend qu'un message ayant l'identificateur spécifié soit disponible dans la file d'attente, ou que le délai d'attente expire.

C#

public System.Messaging.Message PeekByCorrelationId (string correlationId, TimeSpan timeout);

Paramètres

correlationId

String

Propriété CorrelationId du message à lire.

timeout

TimeSpan

TimeSpan qui indique la durée d'attente avant qu'un nouveau message ne soit accessible pour consultation.

Retours

Message

Message dont la propriété CorrelationId correspond au paramètre correlationId passé.

Exceptions

ArgumentNullException

Le paramètre correlationId a la valeur null.

ArgumentException

La valeur spécifiée pour le paramètre timeout n'est pas valide. Il se peut que timeout soit inférieur à Zero ou supérieur à InfiniteTimeout.

InvalidOperationException

Le message ayant le paramètre correlationId spécifié n'existe pas dans la file d'attente et n'est pas arrivé avant l'expiration du délai d'attente.

MessageQueueException

Un message n'est pas arrivé avant l'expiration du délai d'attente.

- ou -

Une erreur s'est produite lors de l'accès à une méthode Message Queuing.

Exemples

L'exemple de code suivant montre l'utilisation de PeekByCorrelationId(String, TimeSpan).

C#

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

// Create a new message.
Message msg = new Message("Example Message Body");

// Designate a queue to receive the acknowledgement message for this
// message.
msg.AdministrationQueue = new MessageQueue(".\\exampleAdminQueue");

// Set the message to generate an acknowledgement message upon its
// arrival.
msg.AcknowledgeType = AcknowledgeTypes.PositiveArrival;

// Send the message.
queue.Send(msg, "Example Message Label");

// Get the message's Id property value.
string id = msg.Id;

// Receive the message from the queue.
msg = queue.ReceiveById(id, TimeSpan.FromSeconds(10.0));

// Connect to the admin queue.
MessageQueue adminQueue = new MessageQueue(".\\exampleAdminQueue");

// Set the admin queue's MessageReadPropertyFilter property to ensure
// that the acknowledgement message includes the desired properties.
adminQueue.MessageReadPropertyFilter.Acknowledgment = true;
adminQueue.MessageReadPropertyFilter.CorrelationId = true;

// Peek at the acknowledgement message.
Message ackMsg = adminQueue.PeekByCorrelationId(id,
    TimeSpan.FromSeconds(10.0));

// Display the acknowledgement message's property values.
Console.WriteLine("Message.Label: {0}", ackMsg.Label);
Console.WriteLine("Message.Acknowledgment: {0}", ackMsg.Acknowledgment);
Console.WriteLine("Message.CorrelationId: {0}", ackMsg.CorrelationId);

Remarques

Cette méthode recherche dans la file d’attente référencée par le MessageQueue pour un message dont CorrelationId le paramètre correspond au paramètre spécifié correlationId . Si aucun message correspondant au correlationID paramètre n’est trouvé et qu’aucun nouveau message n’arrive dans la file d’attente dans la période spécifiée par le timeout paramètre, une exception est levée.

Le timeout paramètre ne spécifie pas la durée totale d’exécution de cette méthode. Au lieu de cela, il spécifie le délai d’attente pour qu’un nouveau message arrive dans la file d’attente. Chaque fois qu’un nouveau message arrive, cette méthode examine le CorrelationId du nouveau message pour voir s’il correspond au correlationId paramètre . Si ce n’est pas le cas, cette méthode démarre le délai d’attente et attend qu’un autre nouveau message arrive. Par conséquent, si de nouveaux messages continuent d’arriver dans le délai imparti, il est possible que cette méthode continue à s’exécuter indéfiniment, soit jusqu’à ce que le délai d’expiration expire sans qu’aucun nouveau message n’arrive, soit jusqu’à ce qu’un message dont CorrelationId le paramètre corresponde à l’arrivée correlationId .

La CorrelationId propriété est utilisée pour lier un message envoyé à la file d’attente aux messages de réponse, de rapport ou d’accusé de réception associés.

Deux autres méthodes vous permettent d’aperçu des messages dans une file d’attente. La Peek méthode retourne le premier message de la file d’attente, et la PeekById(String) méthode est utilisée pour récupérer un message en spécifiant son identificateur unique.

Le tableau suivant indique si cette méthode est disponible dans différents modes de groupe de travail.

Mode groupe de travail	Disponible
Ordinateur local	Oui
Ordinateur local et nom de format direct	Oui
Ordinateur distant	Non
Ordinateur distant et nom de format direct	Oui

Voir aussi

• InfiniteTimeout
• CorrelationId
• Peek()
• BeginPeek()