MessageQueue Classe

Définition

Permet d'accéder à une file d'attente sur un serveur Message Queuing.Provides access to a queue on a Message Queuing server.

public ref 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
type MessageQueue = class
    inherit Component
    interface IEnumerable
Public Class MessageQueue
Inherits Component
Implements IEnumerable
Héritage
Attributs
Implémente

Exemples

L’exemple de code suivant crée de nouveaux objets MessageQueue à l’aide de différents types de syntaxe de nom de chemin d’accès.The following code example creates new MessageQueue objects using various path name syntax types. Dans chaque cas, il envoie un message à la file d’attente dont le chemin est défini dans le constructeur.In each case, it sends a message to the queue whose path is defined in the constructor.

#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 à partir d’une file d’attente, à l’aide d’une classe spécifique à l’application appelée Order.The following code example sends a message to a queue, and receives a message from a queue, using an application-specific class called 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 à des moments différents de communiquer sur des réseaux et des systèmes hétérogènes qui peuvent être temporairement hors connexion.The Message Queuing technology allows applications running at different times to communicate across heterogeneous networks and systems that might be temporarily offline. Les applications envoient, reçoivent ou lisent (lisent sans supprimer) les messages des files d’attente.Applications send, receive, or peek (read without removing) messages from queues. Message Queuing est un composant facultatif de Windows 2000Windows 2000 et Windows NT, et doit être installé séparément.Message Queuing is an optional component of Windows 2000Windows 2000 and Windows NT, and must be installed separately.

La classe MessageQueue est un wrapper autour de Message Queuing.The MessageQueue class is a wrapper around Message Queuing. Il existe plusieurs versions de Message Queuing, et l’utilisation de la classe MessageQueue peut entraîner un comportement légèrement différent, selon le système d’exploitation que vous utilisez.There are multiple versions of Message Queuing, and using the MessageQueue class can result in slightly different behavior, depending on the operating system you are using. Pour plus d’informations sur les fonctionnalités spécifiques de chaque version de Message Queuing, consultez la rubrique « nouveautés de Message Queuing » dans le kit de développement logiciel (SDK) de plateforme dans MSDN.For information about specific features of each version of Message Queuing, see the topic "What's New in Message Queuing" in the Platform SDK in MSDN.

La classe MessageQueue fournit une référence à une file d’attente de Message Queuing.The MessageQueue class provides a reference to a Message Queuing queue. Vous pouvez spécifier un chemin d’accès dans le constructeur MessageQueue pour vous connecter à une ressource existante, ou vous pouvez créer une nouvelle file d’attente sur le serveur.You can specify a path in the MessageQueue constructor to connect to an existing resource, or you can create a new queue on the server. Avant de pouvoir appeler Send(Object), Peekou Receive, vous devez associer la nouvelle instance de la classe MessageQueue à une file d’attente existante.Before you can call Send(Object), Peek, or Receive, you must associate the new instance of the MessageQueue class with an existing queue. À ce stade, vous pouvez manipuler les propriétés de file d’attente, telles que Category et Label.At that point, you can manipulate the queue properties such as Category and Label.

MessageQueue prend en charge deux types de récupération de message : synchrones et asynchrones.MessageQueue supports two types of message retrieval: synchronous and asynchronous. Les méthodes synchrones, Peek et Receive, provoquent l’attente par le thread de processus d’un intervalle de temps spécifié pour l’arrivée d’un nouveau message dans la file d’attente.The synchronous methods, Peek and Receive, cause the process thread to wait a specified time interval for a new message to arrive in the queue. Les méthodes asynchrones, BeginPeek et BeginReceive, permettent aux tâches principales de l’application de continuer dans un thread séparé jusqu’à ce qu’un message arrive dans la file d’attente.The asynchronous methods, BeginPeek and BeginReceive, allow the main application tasks to continue in a separate thread until a message arrives in the queue. Ces méthodes fonctionnent à l’aide d’objets de rappel et d’objets d’État pour communiquer des informations entre les threads.These methods work by using callback objects and state objects to communicate information between threads.

Lorsque vous créez une nouvelle instance de la classe MessageQueue, vous ne créez pas de nouvelle file d’attente Message Queuing.When you create a new instance of the MessageQueue class, you are not creating a new Message Queuing queue. Au lieu de cela, vous pouvez utiliser les méthodes Create(String), Delete(String)et Purge pour gérer les files d’attente sur le serveur.Instead, you can use the Create(String), Delete(String), and Purge methods to manage queues on the server.

Contrairement à Purge, Create(String) et Delete(String) sont des membres static, vous pouvez donc les appeler sans créer une nouvelle instance de la classe MessageQueue.Unlike Purge, Create(String) and Delete(String) are static members, so you can call them without creating a new instance of the MessageQueue class.

Vous pouvez définir la propriété Path de l’objet MessageQueue avec l’un des trois noms suivants : le nom convivial, le FormatNameou le Label.You can set the MessageQueue object's Path property with one of three names: the friendly name, the FormatName, or the Label. Le nom convivial, qui est défini par les propriétés MachineName et QueueName de la file d’attente, est MachineName\QueueName pour une file d’attente publique et MachineName\Private$\QueueName pour une file d’attente privée.The friendly name, which is defined by the queue's MachineName and QueueName properties, is MachineName\QueueName for a public queue, and MachineName\Private$\QueueName for a private queue. La propriété FormatName autorise l’accès hors connexion aux files d’attente de messages.The FormatName property allows offline access to message queues. Enfin, vous pouvez utiliser la propriété de Label de la file d’attente pour définir le Pathde la file d’attente.Lastly, you can use the queue's Label property to set the queue's Path.

Pour obtenir la liste des valeurs de propriétés initiales d’une instance de MessageQueue, consultez le constructeur MessageQueue.For a list of initial property values for an instance of MessageQueue, see the MessageQueue constructor.

Constructeurs

MessageQueue()

Initialise une nouvelle instance de la classe MessageQueue.Initializes a new instance of the MessageQueue class. 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.After the parameterless constructor initializes the new instance, you must set the instance's Path property before you can use the instance.

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é.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path.

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.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path and with the specified read-access restriction.

MessageQueue(String, Boolean, Boolean)

Initialise une nouvelle instance de la classe MessageQueue.Initializes a new instance of the MessageQueue class.

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Initialise une nouvelle instance de la classe MessageQueue.Initializes a new instance of the MessageQueue class.

MessageQueue(String, QueueAccessMode)

Initialise une nouvelle instance de la classe MessageQueue.Initializes a new instance of the MessageQueue class.

Champs

InfiniteQueueSize

Spécifie qu'il n'existe aucune restriction de taille pour la file d'attente.Specifies that no size restriction exists for a queue.

InfiniteTimeout

Spécifie qu'il n'existe pas de délai d'attente pour les méthodes qui lisent ou reçoivent les messages.Specifies that no time-out exists for methods that peek or receive messages.

Propriétés

AccessMode

Obtient une valeur qui indique le mode d'accès pour la file d'attente.Gets a value that indicates the access mode for the queue.

Authenticate

Obtient ou définit une valeur qui indique si la file d'attente accepte uniquement les messages authentifiés.Gets or sets a value that indicates whether the queue accepts only authenticated messages.

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.Gets or sets the base priority Message Queuing uses to route a public queue's messages over the network.

CanRaiseEvents

Obtient une valeur qui indique si le composant peut déclencher un événement.Gets a value indicating whether the component can raise an event.

(Hérité de Component)
CanRead

Obtient une valeur qui indique si MessageQueue peut être lu.Gets a value that indicates whether the MessageQueue can be read.

CanWrite

Obtient une valeur qui indique si MessageQueue peut être accessible en écriture.Gets a value that indicates whether the MessageQueue can be written to.

Category

Obtient ou définit la catégorie de la file d'attente.Gets or sets the queue category.

Container

Obtient le IContainer qui contient Component.Gets the IContainer that contains the Component.

(Hérité de Component)
CreateTime

Obtient l'heure et la date de création de la file d'attente dans Message Queuing.Gets the time and date that the queue was created in 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.Gets or sets the message property values to be used by default when the application sends messages to the queue.

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.Gets or sets a value that indicates whether this MessageQueue has exclusive access to receive messages from the Message Queuing queue.

DesignMode

Obtient une valeur qui indique si Component est actuellement en mode design.Gets a value that indicates whether the Component is currently in design mode.

(Hérité de Component)
EnableConnectionCache

Obtient ou définit une valeur qui indique si l'application conservera un cache de connexions.Gets or sets a value that indicates whether a cache of connections will be maintained by the application.

EncryptionRequired

Obtient ou définit une valeur qui indique si la file d'attente accepte uniquement les messages non privés (non chiffrés).Gets or sets a value that indicates whether the queue accepts only non-private (non-encrypted) messages.

Events

Obtient la liste des gestionnaires d'événements attachés à ce Component.Gets the list of event handlers that are attached to this 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.Gets the unique queue name that Message Queuing generated at the time of the queue's creation.

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.Gets or sets the formatter used to serialize an object into or deserialize an object from the body of a message read from or written to the queue.

Id

Obtient l'identificateur unique de Message Queuing pour la file d'attente.Gets the unique Message Queuing identifier of the queue.

Label

Obtient ou définit la description de la file d'attente.Gets or sets the queue description.

LastModifyTime

Obtient l'heure à laquelle les propriétés d'une file d'attente ont été modifiées pour la dernière fois.Gets the last time the properties of a queue were modified.

MachineName

Obtient ou définit le nom de l'ordinateur où se trouve la file d'attente Message Queuing.Gets or sets the name of the computer where the Message Queuing queue is located.

MaximumJournalSize

Obtient ou définit la taille maximale du journal de file d'attente.Gets or sets the maximum size of the journal queue.

MaximumQueueSize

Obtient ou définit la taille maximale de la file d'attente.Gets or sets the maximum size of the queue.

MessageReadPropertyFilter

Obtient ou définit le filtre appliqué aux propriétés lors de la réception ou de la lecture de messages.Gets or sets the property filter for receiving or peeking messages.

MulticastAddress

Présentation dans MSMQ 3.0.Introduced in MSMQ 3.0. Obtient ou définit l'adresse multicast associée à la file d'attente.Gets or sets the multicast address associated with the queue.

Path

Obtient ou définit le chemin d'accès de la file d'attente.Gets or sets the queue's path. Le paramétrage de Path force MessageQueue à pointer vers une nouvelle file d'attente.Setting the Path causes the MessageQueue to point to a new queue.

QueueName

Obtient ou définit le nom convivial qui identifie la file d'attente.Gets or sets the friendly name that identifies the queue.

ReadHandle

Obtient le handle natif utilisé pour la lecture des messages à partir de la file d'attente de messages.Gets the native handle used to read messages from the message queue.

Site

Obtient ou définit le ISite de Component.Gets or sets the ISite of the 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.Gets or sets the object that marshals the event-handler call resulting from a ReceiveCompleted or PeekCompleted event.

Transactional

Obtient une valeur qui indique si la file d'attente prend en charge les transactions uniquement.Gets a value that indicates whether the queue accepts only transactions.

UseJournalQueue

Obtient ou définit une valeur qui indique si les messages reçus sont copiés dans le journal de file d'attente.Gets or sets a value that indicates whether received messages are copied to the journal queue.

WriteHandle

Obtient le handle natif utilisé pour l'envoi des messages vers la file d'attente de messages.Gets the native handle used to send messages to the message queue.

Méthodes

BeginPeek()

Lance une opération de lecture asynchrone n'ayant pas de délai d'attente. L'opération n'est pas terminée tant qu'un message n'est pas disponible dans la file d'attente.Initiates an asynchronous peek operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginPeek(TimeSpan)

Lance une opération de lecture asynchrone ayant un délai d'attente spécifique. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.Initiates an asynchronous peek operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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é.Initiates an asynchronous peek operation that has a specified time-out and that uses a specified cursor, a specified peek action, and a specified state object. L'objet d'état fournit des informations associées pendant la durée de vie de l'opération.The state object provides associated information throughout the lifetime of the operation. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive()

Lance une opération de réception asynchrone n'ayant pas de délai d'attente. L'opération n'est pas terminée tant qu'un message n'est pas disponible dans la file d'attente.Initiates an asynchronous receive operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginReceive(TimeSpan)

Lance une opération de réception asynchrone ayant un délai d'attente spécifique. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.Initiates an asynchronous receive operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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é.Initiates an asynchronous receive operation that has a specified time-out and uses a specified cursor and a specified state object. L'objet d'état fournit des informations associées pendant la durée de vie de l'opération.The state object provides associated information throughout the lifetime of the operation. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Cette surcharge reçoit, via un rappel, la notification de l'identité du gestionnaire d'événements de l'opération.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'opération ne se termine que lorsqu'un message est disponible dans la file ou lorsque le délai d'attente a expiré.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

ClearConnectionCache()

Vide le cache de connexion.Clears the connection cache.

Close()

Libère toutes les ressources allouées par MessageQueue.Frees all resources allocated by the MessageQueue.

Create(String)

Crée une file d'attente Message Queuing non transactionnelle dans le chemin d'accès spécifié.Creates a non-transactional Message Queuing queue at the specified path.

Create(String, Boolean)

Crée une file d'attente Message Queuing transactionnelle ou non transactionnelle dans le chemin d'accès spécifié.Creates a transactional or non-transactional Message Queuing queue at the specified path.

CreateCursor()

Crée un Cursor pour la file d'attente de messages active.Creates a new Cursor for the current message queue.

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.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Hérité de MarshalByRefObject)
Delete(String)

Supprime une file d'attente sur un serveur Message Queuing.Deletes a queue on a Message Queuing server.

Dispose()

Libère toutes les ressources utilisées par Component.Releases all resources used by the Component.

(Hérité de Component)
Dispose(Boolean)

Libère les ressources (autres que la mémoire) utilisées par MessageQueue.Disposes of the resources (other than memory) used by the MessageQueue.

EndPeek(IAsyncResult)

Termine l'opération de lecture asynchrone spécifiée.Completes the specified asynchronous peek operation.

EndReceive(IAsyncResult)

Termine l'opération de réception asynchrone spécifiée.Completes the specified asynchronous receive operation.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
Exists(String)

Détermine si une file d'attente Message Queuing existe dans le chemin d'accès spécifié.Determines whether a Message Queuing queue exists at the specified path.

GetAllMessages()

Retourne tous les messages qui figurent dans la file d'attente.Returns all the messages that are in the queue.

GetEnumerator()

Énumère les messages d'une file d'attente.Enumerates the messages in a queue. GetEnumerator() est déconseillé.GetEnumerator() is deprecated. Il est préférable d'utiliser GetMessageEnumerator2().GetMessageEnumerator2() should be used instead.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetLifetimeService()

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.Retrieves the current lifetime service object that controls the lifetime policy for this 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.Gets the identifier of the computer on which the queue referenced by this MessageQueue is located.

GetMessageEnumerator()

Crée un objet énumérateur pour tous les messages figurant dans la file d'attente.Creates an enumerator object for all the messages in the queue. GetMessageEnumerator() est déconseillé.GetMessageEnumerator() is deprecated. Il est préférable d'utiliser GetMessageEnumerator2().GetMessageEnumerator2() should be used instead.

GetMessageEnumerator2()

Crée un objet énumérateur pour tous les messages figurant dans la file d'attente.Creates an enumerator object for all the messages in the queue.

GetMessageQueueEnumerator()

Fournit des sémantiques de curseur avant uniquement pour l'énumération de toutes les files d'attente publiques sur le réseau.Provides forward-only cursor semantics to enumerate through all public queues on the network.

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.Provides forward-only cursor semantics to enumerate through all public queues on the network that meet the specified criteria.

GetPrivateQueuesByMachine(String)

Récupère toutes les files d'attente privées sur l'ordinateur spécifié.Retrieves all the private queues on the specified computer.

GetPublicQueues()

Récupère toutes les files d'attente publiques du réseau.Retrieves all the public queues on the network.

GetPublicQueues(MessageQueueCriteria)

Récupère toutes les files d'attente publiques du réseau qui correspondent aux critères spécifiés.Retrieves all the public queues on the network that meet the specified criteria.

GetPublicQueuesByCategory(Guid)

Récupère toutes les files d'attente publiques du réseau qui appartiennent à la catégorie spécifiée.Retrieves all the public queues on the network that belong to the specified category.

GetPublicQueuesByLabel(String)

Récupère toutes les files d'attente publiques du réseau qui sont dotées de l'étiquette spécifiée.Retrieves all the public queues on the network that carry the specified label.

GetPublicQueuesByMachine(String)

Récupère toutes les files d'attente publiques qui résident sur l'ordinateur spécifié.Retrieves all the public queues that reside on the specified computer.

GetSecurityContext()

Récupère le contexte de sécurité que MSMQ associe à l'utilisateur actuel (identité de thread) au moment de cet appel.Retrieves the security context that MSMQ associates with the current user (thread identity) at the time of this call.

GetService(Type)

Retourne un objet qui représente un service fourni par Component ou par son Container.Returns an object that represents a service provided by the Component or by its Container.

(Hérité de Component)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
InitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(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.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. La méthode Peek() étant synchrone, elle bloque le thread en cours jusqu'à ce qu'un message soit disponible.The Peek() method is synchronous, so it blocks the current thread until a message becomes available.

Peek(TimeSpan)

Retourne (lit) le premier message figurant dans la file d'attente référencée par ce MessageQueue sans le supprimer.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. 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.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

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é.Returns without removing (peeks) the current or next message in the queue, using the specified cursor. 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.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

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.Peeks the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

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.Peeks the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

PeekById(String)

Lit le message dont l'identificateur de message correspond au paramètre id.Peeks the message whose message identifier matches the id parameter.

PeekById(String, TimeSpan)

Lit le message dont l'identificateur de message correspond au paramètre id.Peeks the message whose message identifier matches the id parameter. Attend que le message s'affiche dans la file d'attente ou que le délai expire.Waits until the message appears in the queue or a time-out occurs.

PeekByLookupId(Int64)

Présentation dans MSMQ 3.0.Introduced in MSMQ 3.0. Lit le message qui correspond à l'identificateur de recherche donné d'une file d'attente non transactionnelle.Peeks at the message that matches the given lookup identifier from a non-transactional queue.

PeekByLookupId(MessageLookupAction, Int64)

Présentation dans MSMQ 3.0.Introduced in MSMQ 3.0. Lit un message spécifique de la file d'attente.Peeks at a specific message from the queue. 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.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Purge()

Supprime tous les messages contenus dans la file d'attente.Deletes all the messages contained in the queue.

Receive()

Reçoit le premier message disponible dans la file référencée par MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransaction)

Reçoit le premier message disponible dans la file d'attente transactionnelle référencée par MessageQueue.Receives the first message available in the transactional queue referenced by the MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransactionType)

Reçoit le premier message disponible dans la file référencée par MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Cet appel synchrone bloque le thread d'exécution en cours jusqu'à ce qu'un message soit disponible.This call is synchronous, and blocks the current thread of execution until a message is available.

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.Receives the first message available in the queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, Cursor)

Reçoit le message en cours dans la file d'attente, à l'aide d'un curseur spécifié.Receives the current message in the queue, using a specified cursor. Si aucun message n'est disponible, cette méthode attend qu'un message soit disponible ou que le délai d'attente expire.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Reçoit le message en cours dans la file d'attente, à l'aide d'un curseur spécifié.Receives the current message in the queue, using a specified cursor. Si aucun message n'est disponible, cette méthode attend qu'un message soit disponible ou que le délai d'attente expire.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Reçoit le message en cours dans la file d'attente, à l'aide d'un curseur spécifié.Receives the current message in the queue, using a specified cursor. Si aucun message n'est disponible, cette méthode attend qu'un message soit disponible ou que le délai d'attente expire.If no message is available, this method waits until either a message is available, or the time-out expires.

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.Receives the first message available in the transactional queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, MessageQueueTransactionType)

Reçoit le premier message disponible dans la file référencée par MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Cet appel est synchrone et attend qu'un message soit disponible dans la file d'attente ou que le délai expire.This call is synchronous, and waits until either a message is available in the queue, or the time-out expires.

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.Receives the message that matches the given correlation identifier (from a non-transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

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.Receives the message that matches the given correlation identifier (from a transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

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.Receives the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

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.Receives the message that matches the given correlation identifier (from a non-transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

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.Receives the message that matches the given correlation identifier (from a transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

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.Receives the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

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.Receives the message that matches the given identifier from a non-transactional queue and immediately raises an exception if no message with the specified identifier currently exists in the queue.

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.Receives the message that matches the given identifier (from a transactional queue) and immediately raises an exception if no message with the specified identifier currently exists in the queue.

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.Receives the message that matches the given identifier and immediately raises an exception if no message with the specified identifier currently exists in the queue.

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.Receives the message that matches the given identifier (from a non-transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

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.Receives the message that matches the given identifier (from a transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

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.Receives the message that matches the given identifier and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveByLookupId(Int64)

Présentation dans MSMQ 3.0.Introduced in MSMQ 3.0. Reçoit le message qui correspond à l'identificateur de recherche donné d'une file d'attente non transactionnelle.Receives the message that matches the given lookup identifier from a non-transactional queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)

Présentation dans MSMQ 3.0.Introduced in MSMQ 3.0. Reçoit un message spécifique d'une file d'attente transactionnelle.Receives a specific message from a transactional queue. 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.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)

Présentation dans MSMQ 3.0.Introduced in MSMQ 3.0. Reçoit un message spécifique de la file d'attente, à l'aide du contexte de transaction spécifié.Receives a specific message from the queue, using the specified transaction context. 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.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Refresh()

Actualise les propriétés présentées par MessageQueue pour refléter l'état actuel de la ressource.Refreshes the properties presented by the MessageQueue to reflect the current state of the resource.

ResetPermissions()

Réinitialise la liste des autorisations à l'aide des valeurs par défaut du système d'exploitation.Resets the permission list to the operating system's default values. Supprime les autorisations sur des files d'attente ajoutées à la liste par défaut.Removes any queue permissions you have appended to the default list.

Send(Object)

Envoie un objet à la file d'attente non transactionnelle référencée par ce MessageQueue.Sends an object to non-transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransaction)

Envoie un objet à la file d'attente transactionnelle référencée par ce MessageQueue.Sends an object to the transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransactionType)

Envoie un objet à la file d'attente référencée par ce MessageQueue.Sends an object to the queue referenced by this 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.Sends an object to the non-transactional queue referenced by this MessageQueue and specifies a label for the 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.Sends an object to the transactional queue referenced by this MessageQueue and specifies a label for the 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.Sends an object to the queue referenced by this MessageQueue and specifies a label for the 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.Assigns access rights to the queue based on the contents of an access control list.

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.Assigns access rights to the queue based on the contents of an access control entry.

SetPermissions(String, MessageQueueAccessRights)

Donne les droits d'accès spécifiés à un ordinateur, un groupe ou un utilisateur.Gives a computer, group, or user the specified access rights.

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).Gives a computer, group, or user the specified access rights, with the specified access control type (allow, deny, revoke, or set).

ToString()

Retourne un String contenant le nom du Component, s’il en existe un.Returns a String containing the name of the Component, if any. Cette méthode ne doit pas être remplacée.This method should not be overridden.

(Hérité de Component)

Événements

Disposed

Se produit lorsque le composant est supprimé par un appel à la méthode Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Hérité de Component)
PeekCompleted

Se produit lorsqu'un message est lu sans être supprimé de la file d'attente.Occurs when a message is read without being removed from the queue. Cela se produit lors de l'opération asynchrone résultant de la méthode BeginPeek().This is a result of the asynchronous operation, BeginPeek().

ReceiveCompleted

Se produit lorsqu'un message a été supprimé de la file d'attente.Occurs when a message has been removed from the queue. Cet événement est déclenché par l'opération asynchrone BeginReceive().This event is raised by the asynchronous operation, BeginReceive().

Méthodes d’extension

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

S’applique à

Cohérence de thread

Seule la méthode GetAllMessages() est thread-safe.Only the GetAllMessages() method is thread safe.

Voir aussi