MessageQueue Classe

Référence

Définition

Espace de noms:: System.Messaging

Assembly:: System.Messaging.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Permet d'accéder à une file d'attente sur un serveur Message Queuing.

public ref class MessageQueue : System::ComponentModel::Component, System::Collections::IEnumerable

[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
public class MessageQueue : System.ComponentModel.Component, System.Collections.IEnumerable

[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
[System.Messaging.MessagingDescription("MessageQueueDesc")]
public class MessageQueue : System.ComponentModel.Component, System.Collections.IEnumerable

[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
type MessageQueue = class
    inherit Component
    interface IEnumerable

[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
[<System.Messaging.MessagingDescription("MessageQueueDesc")>]
type MessageQueue = class
    inherit Component
    interface IEnumerable

Public Class MessageQueue
Inherits Component
Implements IEnumerable

Héritage: Object

MarshalByRefObject

Component
MessageQueue

Attributs: TypeConverterAttribute MessagingDescriptionAttribute

Implémente: IEnumerable

Exemples

L’exemple de code suivant crée des MessageQueue objets à l’aide de différents types de syntaxe de nom de chemin d’accès. Dans chaque cas, il envoie un message à la file d’attente dont le chemin est défini dans le constructeur.

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:

   // References public queues.
   void SendPublic()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      myQueue->Send( "Public queue by path name." );
      return;
   }


   // References private queues.
   void SendPrivate()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\Private$\\myQueue" );
      myQueue->Send( "Private queue by path name." );
      return;
   }


   // References queues by label.
   void SendByLabel()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "Label:TheLabel" );
      myQueue->Send( "Queue by label." );
      return;
   }


   // References queues by format name.
   void SendByFormatName()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "FormatName:Public=5A5F7535-AE9A-41d4 -935C-845C2AFF7112" );
      myQueue->Send( "Queue by format name." );
      return;
   }


   // References computer journal queues.
   void MonitorComputerJournal()
   {
      MessageQueue^ computerJournal = gcnew MessageQueue( ".\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = computerJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References queue journal queues.
   void MonitorQueueJournal()
   {
      MessageQueue^ queueJournal = gcnew MessageQueue( ".\\myQueue\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = queueJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References dead-letter queues.
   void MonitorDeadLetter()
   {
      MessageQueue^ deadLetter = gcnew MessageQueue( ".\\DeadLetter$" );
      while ( true )
      {
         Message^ deadMessage = deadLetter->Receive();
         
         // Process the dead-letter message.
      }
   }


   // References transactional dead-letter queues.
   void MonitorTransactionalDeadLetter()
   {
      MessageQueue^ TxDeadLetter = gcnew MessageQueue( ".\\XactDeadLetter$" );
      while ( true )
      {
         Message^ txDeadLetter = TxDeadLetter->Receive();
         
         // Process the transactional dead-letter message.
      }
   }

};


//*************************************************
// Provides an entry point into the application.
//         
// This example demonstrates several ways to set
// a queue's path.
//*************************************************
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   myNewQueue->SendPublic();
   myNewQueue->SendPrivate();
   myNewQueue->SendByLabel();
   myNewQueue->SendByFormatName();
   myNewQueue->MonitorComputerJournal();
   myNewQueue->MonitorQueueJournal();
   myNewQueue->MonitorDeadLetter();
   myNewQueue->MonitorTransactionalDeadLetter();
   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 demonstrates several ways to set
        // a queue's path.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            myNewQueue.SendPublic();
            myNewQueue.SendPrivate();
            myNewQueue.SendByLabel();
            myNewQueue.SendByFormatName();
            myNewQueue.MonitorComputerJournal();
            myNewQueue.MonitorQueueJournal();
            myNewQueue.MonitorDeadLetter();
            myNewQueue.MonitorTransactionalDeadLetter();

            return;
        }
        
        // References public queues.
        public void SendPublic()
        {
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Send("Public queue by path name.");

            return;
        }

        // References private queues.
        public void SendPrivate()
        {
            MessageQueue myQueue = new
                MessageQueue(".\\Private$\\myQueue");
            myQueue.Send("Private queue by path name.");

            return;
        }

        // References queues by label.
        public void SendByLabel()
        {
            MessageQueue myQueue = new MessageQueue("Label:TheLabel");
            myQueue.Send("Queue by label.");

            return;
        }

        // References queues by format name.
        public void SendByFormatName()
        {
            MessageQueue myQueue = new
                MessageQueue("FormatName:Public=5A5F7535-AE9A-41d4" +
                "-935C-845C2AFF7112");
            myQueue.Send("Queue by format name.");

            return;
        }

        // References computer journal queues.
        public void MonitorComputerJournal()
        {
            MessageQueue computerJournal = new
                MessageQueue(".\\Journal$");
            while(true)
            {
                Message journalMessage = computerJournal.Receive();
                // Process the journal message.
            }
        }

        // References queue journal queues.
        public void MonitorQueueJournal()
        {
            MessageQueue queueJournal = new
                MessageQueue(".\\myQueue\\Journal$");
            while(true)
            {
                Message journalMessage = queueJournal.Receive();
                // Process the journal message.
            }
        }
        
        // References dead-letter queues.
        public void MonitorDeadLetter()
        {
            MessageQueue deadLetter = new
                MessageQueue(".\\DeadLetter$");
            while(true)
            {
                Message deadMessage = deadLetter.Receive();
                // Process the dead-letter message.
            }
        }

        // References transactional dead-letter queues.
        public void MonitorTransactionalDeadLetter()
        {
            MessageQueue TxDeadLetter = new
                MessageQueue(".\\XactDeadLetter$");
            while(true)
            {
                Message txDeadLetter = TxDeadLetter.Receive();
                // Process the transactional dead-letter message.
            }
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        
        ' Provides an entry point into the application.
        '		 
        ' This example demonstrates several ways to set
        ' a queue's path.
        

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            myNewQueue.SendPublic()
            myNewQueue.SendPrivate()
            myNewQueue.SendByLabel()
            myNewQueue.SendByFormatName()
            myNewQueue.MonitorComputerJournal()
            myNewQueue.MonitorQueueJournal()
            myNewQueue.MonitorDeadLetter()
            myNewQueue.MonitorTransactionalDeadLetter()

            Return

        End Sub


        ' References public queues.
        Public Sub SendPublic()

            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Send("Public queue by path name.")

            Return

        End Sub


        ' References private queues.
        Public Sub SendPrivate()

            Dim myQueue As New MessageQueue(".\Private$\myQueue")
            myQueue.Send("Private queue by path name.")

            Return

        End Sub


        ' References queues by label.
        Public Sub SendByLabel()

            Dim myQueue As New MessageQueue("Label:TheLabel")
            myQueue.Send("Queue by label.")

            Return

        End Sub


        ' References queues by format name.
        Public Sub SendByFormatName()

            Dim myQueue As New _
                MessageQueue("FormatName:Public=" + _
                    "5A5F7535-AE9A-41d4-935C-845C2AFF7112")
            myQueue.Send("Queue by format name.")

            Return

        End Sub


        ' References computer journal queues.
        Public Sub MonitorComputerJournal()

            Dim computerJournal As New MessageQueue(".\Journal$")

            While True

                Dim journalMessage As Message = _
                    computerJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub


        ' References queue journal queues.
        Public Sub MonitorQueueJournal()

            Dim queueJournal As New _
                            MessageQueue(".\myQueue\Journal$")

            While True

                Dim journalMessage As Message = _
                    queueJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub


        ' References dead-letter queues.
        Public Sub MonitorDeadLetter()
            Dim deadLetter As New MessageQueue(".\DeadLetter$")

            While True

                Dim deadMessage As Message = deadLetter.Receive()

                ' Process the dead-letter message.

            End While

            Return

        End Sub


        ' References transactional dead-letter queues.
        Public Sub MonitorTransactionalDeadLetter()

            Dim TxDeadLetter As New MessageQueue(".\XactDeadLetter$")

            While True

                Dim txDeadLetterMessage As Message = _
                    TxDeadLetter.Receive()

                ' Process the transactional dead-letter message.

            End While

            Return

        End Sub

End Class

L’exemple de code suivant envoie un message à une file d’attente et reçoit un message d’une file d’attente, à l’aide d’une classe spécifique à l’application appelée Order.

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

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// sends to a queue and receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends an Order to a queue.
   //*************************************************
   void SendMessage()
   {
      // Create a new order and set values.
      Order^ sentOrder = gcnew Order;
      sentOrder->orderId = 3;
      sentOrder->orderTime = DateTime::Now;

      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Send the Order to the queue.
      myQueue->Send( sentOrder );
      return;
   }

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Order^ myOrder = static_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
//         
// This example sends and receives a message from
// a queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

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

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    // This class represents an object the following example
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <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();

            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Sends an Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            
            // Create a new order and set values.
            Order sentOrder = new Order();
            sentOrder.orderId = 3;
            sentOrder.orderTime = DateTime.Now;

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

            // Send the Order to the queue.
            myQueue.Send(sentOrder);

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                Message myMessage =	myQueue.Receive();
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging

    ' This class represents an object the following example 
    ' sends to a queue and receives from a queue.
    Public Class Order
        Public orderId As Integer
        Public orderTime As DateTime
    End Class


   
    Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        '		 
        ' This example sends and receives a message from
        ' a qeue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Send a message to a queue.
            myNewQueue.SendMessage()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub


        '
        ' Sends an Order to a queue.
        '

        Public Sub SendMessage()

            ' Create a new order and set values.
            Dim sentOrder As New Order()
            sentOrder.orderId = 3
            sentOrder.orderTime = DateTime.Now

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Send the Order to the queue.
            myQueue.Send(sentOrder)

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessage()

            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate the body contains an Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType(Order)})

            Try

                ' Receive and format the message. 
                Dim myMessage As Message = myQueue.Receive()
                Dim myOrder As Order = CType(myMessage.Body, Order)

                ' Display message information.
                Console.WriteLine(("Order ID: " + _
                    myOrder.orderId.ToString()))
                Console.WriteLine(("Sent: " + _
                    myOrder.orderTime.ToString()))

            Catch m As MessageQueueException
                ' Handle Message Queuing exceptions.

            Catch e As InvalidOperationException
                ' Handle invalid serialization format.
                Console.WriteLine(e.Message)


                ' Catch other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Remarques

La technologie Message Queuing permet aux applications exécutées à différents moments de communiquer entre des réseaux et des systèmes hétérogènes qui peuvent être temporairement hors connexion. Les applications envoient, reçoivent ou regardent (lire sans supprimer) des messages des files d’attente. Message Queuing est un composant facultatif de Windows 2000 et Windows NT, et doit être installé séparément.

La MessageQueue classe est un wrapper autour de Message Queuing. Il existe plusieurs versions de Message Queuing, et l’utilisation de la MessageQueue classe peut entraîner un comportement légèrement différent, selon le système d’exploitation que vous utilisez.

La MessageQueue classe fournit une référence à une file d’attente Message Queuing. Vous pouvez spécifier un chemin dans le MessageQueue constructeur pour vous connecter à une ressource existante, ou vous pouvez créer une file d’attente sur le serveur. Avant d’appeler Send(Object), Peekou Receive, vous devez associer la nouvelle instance de la MessageQueue classe à une file d’attente existante. À ce stade, vous pouvez manipuler les propriétés de file d’attente telles que Category et Label.

MessageQueue prend en charge deux types de récupération de messages : synchrone et asynchrone. Les méthodes synchrones, et Receive, Peek obligent le thread de processus à attendre un intervalle de temps spécifié pour qu’un nouveau message arrive dans la file d’attente. Les méthodes asynchrones, et BeginReceive, BeginPeek permettent au main tâches d’application de continuer dans un thread distinct jusqu’à ce qu’un message arrive dans la file d’attente. Ces méthodes fonctionnent à l’aide d’objets de rappel et d’objets d’état pour communiquer des informations entre les threads.

Lorsque vous créez une nouvelle instance de la MessageQueue classe, vous ne créez pas de file d’attente Message Queuing. Au lieu de cela, vous pouvez utiliser les Create(String)méthodes , Delete(String)et Purge pour gérer les files d’attente sur le serveur.

Contrairement à Purgeet Delete(String)Create(String) sont static membres, vous pouvez donc les appeler sans créer de instance de la MessageQueue classe.

Vous pouvez définir la propriété de l’objet MessageQueue avec l’un des trois noms suivants : le nom convivial, le FormatNameou le Label.Path Le nom convivial, qui est défini par les propriétés et de la file d’attenteMachineName, est\QueueName MachineNamepour une file d’attente publique et MachineName QueueName\\Private$pour une file d’attente privée.QueueName La FormatName propriété autorise l’accès hors connexion aux files d’attente de messages. Enfin, vous pouvez utiliser la propriété de Label la file d’attente pour définir la valeur de Pathla file d’attente.

Pour obtenir la liste des valeurs de propriété initiales d’un instance de MessageQueue, consultez le MessageQueue constructeur.

Constructeurs

MessageQueue()	Initialise une nouvelle instance de la classe MessageQueue. Une fois la nouvelle instance initialisée par le constructeur sans paramètre, vous devez définir sa propriété Path avant de pouvoir l’utiliser.
MessageQueue(String)	Initialise une nouvelle instance de la classe MessageQueue qui fait référence à la file d'attente Message Queuing dans le chemin d'accès spécifié.
MessageQueue(String, Boolean)	Initialise une nouvelle instance de la classe MessageQueue qui fait référence à la file d'attente Message Queuing dans le chemin d'accès et avec la restriction d'accès en lecture spécifiés.
MessageQueue(String, Boolean, Boolean)	Initialise une nouvelle instance de la classe MessageQueue.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	Initialise une nouvelle instance de la classe MessageQueue.
MessageQueue(String, QueueAccessMode)	Initialise une nouvelle instance de la classe MessageQueue.

Champs

InfiniteQueueSize	Spécifie qu'il n'existe aucune restriction de taille pour la file d'attente.
InfiniteTimeout	Spécifie qu'il n'existe pas de délai d'attente pour les méthodes qui lisent ou reçoivent les messages.

Propriétés

AccessMode	Obtient une valeur qui indique le mode d'accès pour la file d'attente.
Authenticate	Obtient ou définit une valeur qui indique si la file d'attente accepte uniquement les messages authentifiés.
BasePriority	Obtient ou définit la priorité de base utilisée par Message Queuing pour acheminer les messages d'une file d'attente publique sur le réseau.
CanRaiseEvents	Obtient une valeur qui indique si le composant peut déclencher un événement. (Hérité de Component)
CanRead	Obtient une valeur qui indique si MessageQueue peut être lu.
CanWrite	Obtient une valeur qui indique si MessageQueue peut être accessible en écriture.
Category	Obtient ou définit la catégorie de la file d'attente.
Container	Obtient le IContainer qui contient la Component. (Hérité de Component)
CreateTime	Obtient l'heure et la date de création de la file d'attente dans Message Queuing.
DefaultPropertiesToSend	Obtient ou définit les valeurs de propriétés de message par défaut à utiliser lorsque l'application envoie des messages vers la file d'attente.
DenySharedReceive	Obtient ou définit une valeur qui indique si ce MessageQueue a un droit d'accès exclusif pour la réception des messages de la file d'attente Message Queuing.
DesignMode	Obtient une valeur qui indique si Component est actuellement en mode design. (Hérité de Component)
EnableConnectionCache	Obtient ou définit une valeur qui indique si l'application conservera un cache de connexions.
EncryptionRequired	Obtient ou définit une valeur qui indique si la file d'attente accepte uniquement les messages non privés (non chiffrés).
Events	Obtient la liste des gestionnaires d'événements attachés à ce Component. (Hérité de Component)
FormatName	Obtient le nom unique que Message Queuing a généré pour la file d'attente lors de sa création.
Formatter	Obtient ou définit le formateur utilisé pour sérialiser un objet dans le corps d'un message lu ou écrit dans la file d'attente, ou pour désérialiser l'objet à partir de celui-ci.
Id	Obtient l'identificateur unique de Message Queuing pour la file d'attente.
Label	Obtient ou définit la description de la file d'attente.
LastModifyTime	Obtient l'heure à laquelle les propriétés d'une file d'attente ont été modifiées pour la dernière fois.
MachineName	Obtient ou définit le nom de l'ordinateur où se trouve la file d'attente Message Queuing.
MaximumJournalSize	Obtient ou définit la taille maximale du journal de file d'attente.
MaximumQueueSize	Obtient ou définit la taille maximale de la file d'attente.
MessageReadPropertyFilter	Obtient ou définit le filtre appliqué aux propriétés lors de la réception ou de la lecture de messages.
MulticastAddress	Présentation dans MSMQ 3.0. Obtient ou définit l'adresse multicast associée à la file d'attente.
Path	Obtient ou définit le chemin d'accès de la file d'attente. Le paramétrage de Path force MessageQueue à pointer vers une nouvelle file d'attente.
QueueName	Obtient ou définit le nom convivial qui identifie la file d'attente.
ReadHandle	Obtient le handle natif utilisé pour la lecture des messages à partir de la file d'attente de messages.
Site	Obtient ou définit le ISite de Component. (Hérité de Component)
SynchronizingObject	Obtient ou définit l'objet utilisé pour marshaler l'appel du gestionnaire d'événements consécutif à un événement ReceiveCompleted ou PeekCompleted.
Transactional	Obtient une valeur qui indique si la file d'attente prend en charge les transactions uniquement.
UseJournalQueue	Obtient ou définit une valeur qui indique si les messages reçus sont copiés dans le journal de file d'attente.
WriteHandle	Obtient le handle natif utilisé pour l'envoi des messages vers la file d'attente de messages.

Méthodes

BeginPeek()	Lance une opération de lecture asynchrone sans délai d’expiration. L’opération n’est pas terminée tant qu’un message ne s’affiche pas dans la file d’attente.
BeginPeek(TimeSpan)	Lance une opération de peek asynchrone avec un délai d’expiration spécifié. L’opération n’est pas terminée tant qu’un message ne s’affiche pas dans la file d’attente ou que l’opération n’a pas expiré.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Initialise une opération de lecture asynchrone qui a un délai d'expiration spécifié et utilise un curseur spécifié, une action de lecture spécifiée et un objet d'état spécifié. L'objet d'état fournit des informations associées pendant la durée de vie de l'opération. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.
BeginPeek(TimeSpan, Object)	Lance une opération de lecture asynchrone avec un délai et un objet d'état spécifiés, permettant ainsi de disposer de données associées pendant toute la durée de vie de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.
BeginPeek(TimeSpan, Object, AsyncCallback)	Lance une opération de lecture asynchrone avec un délai et un objet d'état spécifiés, permettant ainsi de disposer de données associées pendant toute la durée de vie de l'opération. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.
BeginReceive()	Lance une opération de réception asynchrone sans délai d’expiration. L’opération n’est pas terminée tant qu’un message ne s’affiche pas dans la file d’attente.
BeginReceive(TimeSpan)	Lance une opération de réception asynchrone avec un délai d’expiration spécifié. L’opération n’est pas terminée tant qu’un message ne s’affiche pas dans la file d’attente ou que l’opération n’a pas expiré.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	Lance une opération de réception asynchrone qui a un délai d'attente spécifié et utilise un curseur spécifié et un objet d'état spécifié. L'objet d'état fournit des informations associées pendant la durée de vie de l'opération. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.
BeginReceive(TimeSpan, Object)	Lance une opération de réception asynchrone avec un délai et un objet d'état spécifiés, permettant ainsi de disposer de données associées pendant toute la durée de vie de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.
BeginReceive(TimeSpan, Object, AsyncCallback)	Lance une opération de réception asynchrone avec un délai et un objet d'état spécifiés, permettant ainsi de disposer de données associées pendant toute la durée de vie de l'opération. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.
ClearConnectionCache()	Vide le cache de connexion.
Close()	Libère toutes les ressources allouées par MessageQueue.
Create(String)	Crée une file d'attente Message Queuing non transactionnelle dans le chemin d'accès spécifié.
Create(String, Boolean)	Crée une file d'attente Message Queuing transactionnelle ou non transactionnelle dans le chemin d'accès spécifié.
CreateCursor()	Crée un Cursor pour la file d'attente de messages active.
CreateObjRef(Type)	Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject)
Delete(String)	Supprime une file d'attente sur un serveur Message Queuing.
Dispose()	Libère toutes les ressources utilisées par Component. (Hérité de Component)
Dispose(Boolean)	Libère les ressources (autres que la mémoire) utilisées par MessageQueue.
EndPeek(IAsyncResult)	Termine l'opération de lecture asynchrone spécifiée.
EndReceive(IAsyncResult)	Termine l'opération de réception asynchrone spécifiée.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
Exists(String)	Détermine si une file d'attente Message Queuing existe dans le chemin d'accès spécifié.
GetAllMessages()	Retourne tous les messages qui figurent dans la file d'attente.
GetEnumerator()	Obsolète. Énumère les messages d'une file d'attente. GetEnumerator() est déconseillé. Il est préférable d'utiliser GetMessageEnumerator2().
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	Obsolète. Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetMachineId(String)	Obtient l'identificateur de l'ordinateur sur lequel figure la file d'attente à laquelle ce MessageQueue fait référence.
GetMessageEnumerator()	Obsolète. Crée un objet énumérateur pour tous les messages figurant dans la file d'attente. GetMessageEnumerator() est déconseillé. Il est préférable d'utiliser GetMessageEnumerator2().
GetMessageEnumerator2()	Crée un objet énumérateur pour tous les messages figurant dans la file d'attente.
GetMessageQueueEnumerator()	Fournit des sémantiques de curseur avant uniquement pour l'énumération de toutes les files d'attente publiques sur le réseau.
GetMessageQueueEnumerator(MessageQueueCriteria)	Fournit des sémantiques de curseur avant uniquement pour l'énumération de toutes les files d'attente publiques sur le réseau qui correspondent aux critères spécifiés.
GetPrivateQueuesByMachine(String)	Récupère toutes les files d'attente privées sur l'ordinateur spécifié.
GetPublicQueues()	Récupère toutes les files d'attente publiques du réseau.
GetPublicQueues(MessageQueueCriteria)	Récupère toutes les files d'attente publiques du réseau qui correspondent aux critères spécifiés.
GetPublicQueuesByCategory(Guid)	Récupère toutes les files d'attente publiques du réseau qui appartiennent à la catégorie spécifiée.
GetPublicQueuesByLabel(String)	Récupère toutes les files d'attente publiques du réseau qui sont dotées de l'étiquette spécifiée.
GetPublicQueuesByMachine(String)	Récupère toutes les files d'attente publiques qui résident sur l'ordinateur spécifié.
GetSecurityContext()	Récupère le contexte de sécurité que MSMQ associe à l'utilisateur actuel (identité de thread) au moment de cet appel.
GetService(Type)	Retourne un objet qui représente un service fourni par Component ou par son Container. (Hérité de Component)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
InitializeLifetimeService()	Obsolète. Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
Peek()	Retourne (lit) le premier message figurant dans la file d'attente référencée par ce MessageQueue sans le supprimer. La méthode Peek() étant synchrone, elle bloque le thread en cours jusqu'à ce qu'un message soit disponible.
Peek(TimeSpan)	Retourne (lit) le premier message figurant dans la file d'attente référencée par ce MessageQueue sans le supprimer. La méthode Peek() étant synchrone, elle bloque le thread en cours jusqu'à ce qu'un message soit disponible ou que le délai spécifié expire.
Peek(TimeSpan, Cursor, PeekAction)	Retourne (lit) le message actuel ou le message suivant de la file d'attente sans le supprimer, à l'aide du curseur spécifié. La méthode Peek() étant synchrone, elle bloque le thread en cours jusqu'à ce qu'un message soit disponible ou que le délai spécifié 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.
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.
PeekById(String)	Lit le message dont l'identificateur de message correspond au paramètre `id`.
PeekById(String, TimeSpan)	Lit le message dont l'identificateur de message correspond au paramètre `id`. Attend que le message s'affiche dans la file d'attente ou que le délai expire.
PeekByLookupId(Int64)	Présentation dans MSMQ 3.0. Lit le message qui correspond à l'identificateur de recherche donné d'une file d'attente non transactionnelle.
PeekByLookupId(MessageLookupAction, Int64)	Présentation dans MSMQ 3.0. Lit un message spécifique de la file d'attente. Le message peut être spécifié par un identificateur de recherche ou par sa position au début ou à la fin de la file d'attente.
Purge()	Supprime tous les messages contenus dans la file d'attente.
Receive()	Reçoit le premier message disponible dans la file référencée par MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.
Receive(MessageQueueTransaction)	Reçoit le premier message disponible dans la file d'attente transactionnelle référencée par MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.
Receive(MessageQueueTransactionType)	Reçoit le premier message disponible dans la file référencée par MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.
Receive(TimeSpan)	Reçoit le premier message disponible dans la file d'attente référencée par MessageQueue et attend qu'un message soit disponible dans la file ou que le délai d'attente expire.
Receive(TimeSpan, Cursor)	Reçoit le message en cours dans la file d'attente, à l'aide d'un curseur spécifié. Si aucun message n'est disponible, cette méthode attend qu'un message soit disponible ou que le délai d'attente expire.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Reçoit le message en cours dans la file d'attente, à l'aide d'un curseur spécifié. Si aucun message n'est disponible, cette méthode attend qu'un message soit disponible ou que le délai d'attente expire.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Reçoit le message en cours dans la file d'attente, à l'aide d'un curseur spécifié. Si aucun message n'est disponible, cette méthode attend qu'un message soit disponible ou que le délai d'attente expire.
Receive(TimeSpan, MessageQueueTransaction)	Reçoit le premier message disponible dans la file d'attente transactionnelle référencée par MessageQueue et attend qu'un message soit disponible dans la file d'attente ou que le délai d'attente expire.
Receive(TimeSpan, MessageQueueTransactionType)	Reçoit le premier message disponible dans la file référencée par MessageQueue. Cet appel est synchrone et attend qu'un message soit disponible dans la file d'attente ou que le délai expire.
ReceiveByCorrelationId(String)	Reçoit le message qui correspond à l'identificateur de corrélation donné (à partir d'une file d'attente non transactionnelle), et lève immédiatement une exception si la file ne contient aucun message correspondant à cet identificateur.
ReceiveByCorrelationId(String, MessageQueueTransaction)	Reçoit le message qui correspond à l'identificateur de corrélation donné (à partir d'une file d'attente transactionnelle), et lève immédiatement une exception si la file ne contient aucun message correspondant à cet identificateur.
ReceiveByCorrelationId(String, MessageQueueTransactionType)	Reçoit le message qui correspond à l'identificateur de corrélation donné et lève immédiatement une exception si la file d'attente ne contient aucun message correspondant à cet identificateur.
ReceiveByCorrelationId(String, TimeSpan)	Reçoit le message qui correspond à l'identificateur de corrélation donné, (à partir d'une file non transactionnelle), puis attend qu'un message ayant cet identificateur soit disponible dans la file d'attente, ou que le délai d'attente expire.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)	Reçoit le message qui correspond à l'identificateur de corrélation donné, (à partir d'une file d'attente transactionnelle), puis attend qu'un message ayant cet identificateur soit disponible dans la file d'attente, ou que le délai d'attente expire.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)	Reçoit 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.
ReceiveById(String)	Reçoit le message qui correspond à l'identificateur spécifié à partir d'une file d'attente non transactionnelle, et lève immédiatement une exception si la file ne contient aucun message correspondant à cet identificateur.
ReceiveById(String, MessageQueueTransaction)	Reçoit le message qui correspond à l'identificateur spécifié (à partir d'une file d'attente transactionnelle), et lève immédiatement une exception si la file ne contient aucun message correspondant à cet identificateur.
ReceiveById(String, MessageQueueTransactionType)	Reçoit le message qui correspond à l'identificateur spécifié et lève immédiatement une exception si la file d'attente ne contient aucun message correspondant à cet identificateur.
ReceiveById(String, TimeSpan)	Reçoit le message qui correspond à l'identificateur donné (à partir d'une file d'attente non transactionnelle), puis attend qu'un message ayant cet identificateur soit disponible dans la file d'attente, ou que le délai d'attente expire.
ReceiveById(String, TimeSpan, MessageQueueTransaction)	Reçoit le message qui correspond à l'identificateur donné (à partir d'une file d'attente transactionnelle), puis attend qu'un message ayant cet identificateur soit disponible dans la file d'attente, ou que le délai d'attente expire.
ReceiveById(String, TimeSpan, MessageQueueTransactionType)	Reçoit le message qui correspond à l'identificateur 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.
ReceiveByLookupId(Int64)	Présentation dans MSMQ 3.0. Reçoit le message qui correspond à l'identificateur de recherche donné d'une file d'attente non transactionnelle.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)	Présentation dans MSMQ 3.0. Reçoit un message spécifique d'une file d'attente transactionnelle. Le message peut être spécifié par un identificateur de recherche ou par sa position au début ou à la fin de la file d'attente.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)	Présentation dans MSMQ 3.0. Reçoit un message spécifique de la file d'attente, à l'aide du contexte de transaction spécifié. Le message peut être spécifié par un identificateur de recherche ou par sa position au début ou à la fin de la file d'attente.
Refresh()	Actualise les propriétés présentées par MessageQueue pour refléter l'état actuel de la ressource.
ResetPermissions()	Réinitialise la liste des autorisations à l'aide des valeurs par défaut du système d'exploitation. Supprime les autorisations sur des files d'attente ajoutées à la liste par défaut.
Send(Object)	Envoie un objet à la file d'attente non transactionnelle référencée par ce MessageQueue.
Send(Object, MessageQueueTransaction)	Envoie un objet à la file d'attente transactionnelle référencée par ce MessageQueue.
Send(Object, MessageQueueTransactionType)	Envoie un objet à la file d'attente référencée par ce MessageQueue.
Send(Object, String)	Envoie un objet à la file d'attente non transactionnelle référencée par ce MessageQueue et spécifie une étiquette pour le message.
Send(Object, String, MessageQueueTransaction)	Envoie un objet à la file d'attente transactionnelle référencée par ce MessageQueue et spécifie une étiquette pour le message.
Send(Object, String, MessageQueueTransactionType)	Envoie un objet à la file d'attente référencée par ce MessageQueue et spécifie une étiquette pour le message.
SetPermissions(AccessControlList)	Assigne les droits d'accès à la file d'attente en fonction du contenu d'une liste de contrôle d'accès.
SetPermissions(MessageQueueAccessControlEntry)	Assigne des droits d'accès à la file d'attente en fonction du contenu d'une entrée du contrôle d'accès.
SetPermissions(String, MessageQueueAccessRights)	Donne les droits d'accès spécifiés à un ordinateur, un groupe ou un utilisateur.
SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType)	Accorde à un ordinateur, à un groupe ou à un utilisateur les droits d'accès spécifiés, avec le type de contrôle d'accès spécifié (allow, deny, revoke ou set).
ToString()	Retourne un String contenant le nom du Component, s’il en existe un. Cette méthode ne doit pas être remplacée. (Hérité de Component)

Événements

Disposed	Se produit lorsque le composant est supprimé par un appel à la méthode Dispose(). (Hérité de Component)
PeekCompleted	Se produit lorsqu'un message est lu sans être supprimé de la file d'attente. Cela se produit lors de l'opération asynchrone résultant de la méthode BeginPeek().
ReceiveCompleted	Se produit lorsqu'un message a été supprimé de la file d'attente. Cet événement est déclenché par l'opération asynchrone BeginReceive().

Méthodes d’extension

Cast<TResult>(IEnumerable)	Effectue un cast des éléments d'un IEnumerable vers le type spécifié.
OfType<TResult>(IEnumerable)	Filtre les éléments d'un IEnumerable en fonction du type spécifié.
AsParallel(IEnumerable)	Active la parallélisation d'une requête.
AsQueryable(IEnumerable)	Convertit un IEnumerable en IQueryable.

S’applique à

Cohérence de thread

Seule la GetAllMessages() méthode est thread safe.

Partager via