MessageQueue Constructeurs

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.

Initialise une nouvelle instance de la classe MessageQueue.

Surcharges

MessageQueue()	Initialise une nouvelle instance de la classe MessageQueue. Une fois que le constructeur sans paramètre initialise la nouvelle instance, vous devez définir la propriété Path de l’instance avant de pouvoir utiliser l’instance.
MessageQueue(String)	Initialise une nouvelle instance de la classe MessageQueue qui fait référence à la file d’attente Message Queuing au chemin spécifié.
MessageQueue(String, Boolean)	Initialise une nouvelle instance de la classe MessageQueue qui référence la file d’attente Message Queuing au chemin d’accès spécifié et avec la restriction d’accès en lecture spécifiée.
MessageQueue(String, QueueAccessMode)	Initialise une nouvelle instance de la classe MessageQueue.
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()

Initialise une nouvelle instance de la classe MessageQueue. Une fois que le constructeur sans paramètre initialise la nouvelle instance, vous devez définir la propriété Path de l’instance avant de pouvoir utiliser l’instance.

public:
 MessageQueue();

public MessageQueue ();

Public Sub New ()

Exemples

L’exemple de code suivant crée une nouvelle MessageQueue.

// Connect to a queue on the local computer. You must set the queue's
// Path property before you can use the queue.
MessageQueue queue = new MessageQueue();
queue.Path = ".\\exampleQueue";

Remarques

Utilisez cette surcharge pour créer une instance de la classe MessageQueue qui n’est pas immédiatement liée à une file d’attente sur le serveur Message Queuing. Avant d’utiliser cette instance, vous devez la connecter à une file d’attente Message Queuing existante en définissant la propriété Path. Vous pouvez également définir la référence MessageQueue à la valeur de retour de la méthode Create(String), créant ainsi une nouvelle file d’attente Message Queuing.

Le constructeur MessageQueue instancie une nouvelle instance de la classe MessageQueue ; il ne crée pas de file d’attente Message Queuing.

Le tableau suivant présente les valeurs de propriété initiales d’une instance de MessageQueue.

Propriété	Valeur initiale
DefaultPropertiesToSend	Valeurs définies par le constructeur sans paramètre de la classe DefaultPropertiesToSend.
Formatter	XmlMessageFormatter
MessageReadPropertyFilter	Valeurs définies par le constructeur sans paramètre de la classe MessagePropertyFilter. Toutes les valeurs de filtre sont définies sur `true`.
DenySharedReceive	`false`

Voir aussi

S’applique à

MessageQueue(String)

Initialise une nouvelle instance de la classe MessageQueue qui fait référence à la file d’attente Message Queuing au chemin spécifié.

public:
 MessageQueue(System::String ^ path);

public MessageQueue (string path);

new System.Messaging.MessageQueue : string -> System.Messaging.MessageQueue

Public Sub New (path As String)

Paramètres

path: String

Emplacement de la file d’attente référencée par cette MessageQueue.

Exceptions

ArgumentException

La propriété Path n’est pas valide, peut-être parce qu’elle n’a pas été définie.

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. Dans chaque cas, il envoie un message à la file d’attente dont le chemin d’accès 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

Remarques

Utilisez cette surcharge lorsque vous souhaitez lier la nouvelle instance de MessageQueue à une file d’attente Message Queuing particulière, pour laquelle vous connaissez le chemin, le nom de format ou l’étiquette. Si vous souhaitez accorder un accès exclusif à la première application qui fait référence à la file d’attente, vous devez définir la propriété DenySharedReceive sur true ou utiliser le constructeur qui transmet un paramètre de restriction d’accès en lecture.

Le constructeur MessageQueue instancie une nouvelle instance de la classe MessageQueue ; il ne crée pas de file d’attente Message Queuing. Pour créer une file d’attente dans Message Queuing, utilisez Create(String).

La syntaxe du paramètre path dépend du type de file d’attente qu’il référence, comme indiqué dans le tableau suivant.

Type de file d’attente	Syntaxe
File d’attente publique	`MachineName`\`QueueName`
File d’attente privée	`MachineName`\`Private$`\`QueueName`
File d’attente de journaux	`MachineName`\`QueueName`\`Journal$`
File d’attente du journal de l’ordinateur	`MachineName`\`Journal$`
File d’attente de lettres mortes de l’ordinateur	`MachineName`\`Deadletter$`
File d’attente de lettres mortes de l’ordinateur	`MachineName`\`XactDeadletter$`

Vous pouvez également utiliser la FormatName ou Label pour décrire le chemin d’accès de la file d’attente, comme indiqué dans le tableau suivant.

Référence	Syntaxe	Exemple
Nom du format	`FormatName:` [ nom de format ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:` `NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress` \ `QueueName` `FormatName:DIRECT=OS:` `MachineName` \ `QueueName`
Étiquette	`Label:` [ étiquette ]	`Label:` TheLabel

Pour travailler hors connexion, vous devez utiliser la syntaxe de nom de format, et non la syntaxe du nom du chemin d’accès pour le constructeur. Sinon, une exception est levée, car le contrôleur de domaine principal n’est pas disponible pour résoudre le chemin d’accès au nom de format.

Le tableau suivant présente les valeurs de propriété initiales d’une instance de MessageQueue. Ces valeurs sont basées sur les propriétés de la file d’attente Message Queuing avec le chemin d’accès spécifié par le paramètre path.

Propriété	Valeur initiale
Authenticate	`false`
BasePriority	0
Category	Empty
DefaultPropertiesToSend	Valeurs définies par le constructeur sans paramètre de la classe DefaultPropertiesToSend.
EncryptionRequired	`true`, si le paramètre de niveau de confidentialité de la file d’attente Message Queuing est « Corps » ; sinon, `false`.
Formatter	XmlMessageFormatter
Label	Empty
MachineName	Valeur de la propriété nom d’ordinateur de la file d’attente Message Queuing.
MaximumJournalSize	InfiniteQueueSize
MaximumQueueSize	InfiniteQueueSize
MessageReadPropertyFilter	Valeurs définies par le constructeur sans paramètre de la classe MessagePropertyFilter.
Path	Empty, s’il n’est pas défini par le constructeur.
QueueName	Empty, s’il n’est pas défini par le constructeur.
DenySharedReceive	`false`
UseJournalQueue	`true`, si le paramètre journal de l’objet Message Queuing est activé ; sinon, `false`.

Voir aussi

S’applique à

MessageQueue(String, Boolean)

Initialise une nouvelle instance de la classe MessageQueue qui référence la file d’attente Message Queuing au chemin d’accès spécifié et avec la restriction d’accès en lecture spécifiée.

public:
 MessageQueue(System::String ^ path, bool sharedModeDenyReceive);

public MessageQueue (string path, bool sharedModeDenyReceive);

new System.Messaging.MessageQueue : string * bool -> System.Messaging.MessageQueue

Public Sub New (path As String, sharedModeDenyReceive As Boolean)

Paramètres

path: String

Emplacement de la file d’attente référencée par cette MessageQueue, qui peut être « ».

sharedModeDenyReceive: Boolean

true accorder un accès en lecture exclusif à la première application qui accède à la file d’attente ; sinon, false.

Exceptions

ArgumentException

La propriété Path n’est pas valide, peut-être parce qu’elle n’a pas été définie.

Exemples

L’exemple de code suivant crée une nouvelle MessageQueue avec un accès exclusif, définit son chemin d’accès et envoie un message à la file d’attente.

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

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

   // Requests exlusive read access to the queue. If
   // access is granted, receives a message from the 
   // queue.
   void GetExclusiveAccess()
   {
      try
      {
         
         // Request exclusive read access to the queue.
         MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue",true );
         
         // Receive a message. This is where SharingViolation 
         // exceptions would be thrown.
         Message^ myMessage = myQueue->Receive();
      }
      catch ( MessageQueueException^ e ) 
      {
         
         // Handle request for denial of exclusive read access.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::SharingViolation )
         {
            Console::WriteLine( "Denied exclusive read access" );
         }

         
         // Handle other sources of a MessageQueueException.
      }

      
      // Handle other exceptions as necessary.
      return;
   }

};


// Provides an entry point into the application.
// This example connects to a message queue, and
// requests exclusive read access to the queue.
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   
   // Output the count of Lowest priority messages.
   myNewQueue->GetExclusiveAccess();
   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 connects to a message queue, and
        // requests exclusive read access to the queue.
        //**************************************************

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

            // Output the count of Lowest priority messages.
            GetExclusiveAccess();
                        
            return;
        }

        //**************************************************
        // Requests exlusive read access to the queue. If
        // access is granted, receives a message from the
        // queue.
        //**************************************************
        
        public static void GetExclusiveAccess()
        {
            try
            {
                // Request exclusive read access to the queue.
                MessageQueue myQueue = new
                    MessageQueue(".\\myQueue", true);

                // Receive a message. This is where SharingViolation
                // exceptions would be thrown.
                Message myMessage = myQueue.Receive();
            }
            
            catch (MessageQueueException e)
            {
                // Handle request for denial of exclusive read access.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.SharingViolation)
                {
                    Console.WriteLine("Denied exclusive read access");
                }

                // Handle other sources of a MessageQueueException.
            }

            // Handle other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        ' Provides an entry point into the application.
        '		 
        ' This example connects to a message queue, and
        ' requests exclusive read access to the queue.
 

        Public Shared Sub Main()

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

            ' Output the count of Lowest priority messages.
            myNewQueue.GetExclusiveAccess()

            Return

        End Sub


  
        ' Requests exlusive read access to the queue. If
        ' access is granted, receives a message from the 
        ' queue.
  

        Public Sub GetExclusiveAccess()

            Try

                ' Request exclusive read access to the queue.
                Dim myQueue As New MessageQueue(".\myQueue", True)

                ' Receive a message. This is where a SharingViolation 
                ' exception would be thrown.
                Dim myMessage As Message = myQueue.Receive()

            Catch e As MessageQueueException

                ' Handle request for denial of exclusive read access.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.SharingViolation Then

                    Console.WriteLine("Denied exclusive read access.")

                End If

                ' Handle other sources of a MessageQueueException.

                ' Handle other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Remarques

Utilisez cette surcharge lorsque vous souhaitez lier la nouvelle MessageQueue à une file d’attente Message Queuing particulière, pour laquelle vous connaissez le chemin d’accès, le nom de format ou l’étiquette. Si vous souhaitez accorder un accès exclusif à la première application qui fait référence à la file d’attente, définissez le paramètre sharedModeDenyReceive sur true. Sinon, définissez sharedModeDenyReceive sur false ou utilisez le constructeur qui n’a qu’un paramètre path.

Définir sharedModeDenyReceive sur true affecte tous les objets qui accèdent à la file d’attente Message Queuing, y compris d’autres applications. Les effets du paramètre ne sont pas limités à cette application.

Le constructeur MessageQueue crée une nouvelle instance de la classe MessageQueue ; il ne crée pas de file d’attente Message Queuing. Pour créer une file d’attente dans Message Queuing, utilisez Create(String).

La syntaxe du paramètre path dépend du type de file d’attente.

Type de file d’attente	Syntaxe
File d’attente publique	`MachineName`\`QueueName`
File d’attente privée	`MachineName`\`Private$`\`QueueName`
File d’attente de journaux	`MachineName`\`QueueName`\`Journal$`
File d’attente du journal de l’ordinateur	`MachineName`\`Journal$`
File d’attente de lettres mortes de l’ordinateur	`MachineName`\`Deadletter$`
File d’attente de lettres mortes de l’ordinateur	`MachineName`\`XactDeadletter$`

Vous pouvez également utiliser le nom de format ou l’étiquette d’une file d’attente Message Queuing pour décrire le chemin d’accès à la file d’attente.

Référence	Syntaxe	Exemple
Nom du format	`FormatName:` [ nom de format ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:` `NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress` \ `QueueName` `FormatName:DIRECT=OS:` `MachineName` \ `QueueName`
Étiquette	`Label:` [ étiquette ]	`Label:` TheLabel

Pour travailler hors connexion, vous devez utiliser la syntaxe de nom de format plutôt que la syntaxe de nom convivial. Sinon, une exception est levée, car le contrôleur de domaine principal (sur lequel Réside Active Directory) n’est pas disponible pour résoudre le chemin d’accès au nom de format.

Si un MessageQueue ouvre une file d’attente avec le paramètre sharedModeDenyReceive défini sur true, tout MessageQueue qui tente ensuite de lire à partir de la file d’attente génère une MessageQueueException en raison d’une violation de partage. Une MessageQueueException est également levée si un MessageQueue tente d’accéder à la file d’attente en mode exclusif, tandis qu’un autre MessageQueue dispose déjà d’un accès non exclusif à la file d’attente.

Le tableau suivant présente les valeurs de propriété initiales d’une instance de MessageQueue. Ces valeurs sont basées sur les propriétés de la file d’attente Message Queuing, avec le chemin d’accès spécifié par le paramètre path.

Propriété	Valeur initiale
Authenticate	`false`.
BasePriority	0.
Category	Empty.
DefaultPropertiesToSend	Valeurs définies par le constructeur sans paramètre de la classe DefaultPropertiesToSend.
EncryptionRequired	`true`, si le paramètre de niveau de confidentialité de la file d’attente Message Queuing est « Corps » ; sinon, `false`.
Formatter	XmlMessageFormatter.
Label	Empty.
MachineName	Valeur de la propriété nom d’ordinateur de la file d’attente Message Queuing.
MaximumJournalSize	InfiniteQueueSize.
MaximumQueueSize	InfiniteQueueSize.
MessageReadPropertyFilter	Valeurs définies par le constructeur sans paramètre de la classe MessagePropertyFilter.
Path	Empty, s’il n’est pas défini par le constructeur.
QueueName	Empty, s’il n’est pas défini par le constructeur.
DenySharedReceive	Valeur du paramètre `sharedModeDenyReceive`.
UseJournalQueue	`true`, si le paramètre journal de l’objet Message Queuing est activé ; sinon, `false`.

Voir aussi

S’applique à

MessageQueue(String, QueueAccessMode)

Initialise une nouvelle instance de la classe MessageQueue.

public:
 MessageQueue(System::String ^ path, System::Messaging::QueueAccessMode accessMode);

public MessageQueue (string path, System.Messaging.QueueAccessMode accessMode);

new System.Messaging.MessageQueue : string * System.Messaging.QueueAccessMode -> System.Messaging.MessageQueue

Public Sub New (path As String, accessMode As QueueAccessMode)

Paramètres

path: String

Emplacement de la file d’attente référencée par cette MessageQueue, qui peut être « ».

accessMode: QueueAccessMode

Une des valeurs QueueAccessMode.

S’applique à

MessageQueue(String, Boolean, Boolean)

Initialise une nouvelle instance de la classe MessageQueue.

public:
 MessageQueue(System::String ^ path, bool sharedModeDenyReceive, bool enableCache);

public MessageQueue (string path, bool sharedModeDenyReceive, bool enableCache);

new System.Messaging.MessageQueue : string * bool * bool -> System.Messaging.MessageQueue

Public Sub New (path As String, sharedModeDenyReceive As Boolean, enableCache As Boolean)

Paramètres

path: String

Emplacement de la file d’attente référencée par cette MessageQueue, qui peut être « ».

sharedModeDenyReceive: Boolean

true accorder un accès en lecture exclusif à la première application qui accède à la file d’attente ; sinon, false.

enableCache: Boolean

true créer et utiliser un cache de connexion ; sinon, false.

Exemples

L’exemple de code suivant crée une nouvelle MessageQueue avec un accès en lecture exclusif et une mise en cache de connexion activée.

// Connect to a queue on the local computer, grant exclusive read
// access to the first application that accesses the queue, and
// enable connection caching.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue", true, true);

queue->Close();

// Connect to a queue on the local computer, grant exclusive read
// access to the first application that accesses the queue, and
// enable connection caching.
MessageQueue queue = new MessageQueue(".\\exampleQueue", true, true);

S’applique à

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Initialise une nouvelle instance de la classe MessageQueue.

public:
 MessageQueue(System::String ^ path, bool sharedModeDenyReceive, bool enableCache, System::Messaging::QueueAccessMode accessMode);

public MessageQueue (string path, bool sharedModeDenyReceive, bool enableCache, System.Messaging.QueueAccessMode accessMode);

new System.Messaging.MessageQueue : string * bool * bool * System.Messaging.QueueAccessMode -> System.Messaging.MessageQueue

Public Sub New (path As String, sharedModeDenyReceive As Boolean, enableCache As Boolean, accessMode As QueueAccessMode)

Paramètres

path: String

Emplacement de la file d’attente référencée par cette MessageQueue, qui peut être « ».

sharedModeDenyReceive: Boolean

true accorder un accès en lecture exclusif à la première application qui accède à la file d’attente ; sinon, false.

enableCache: Boolean

true créer et utiliser un cache de connexion ; sinon, false.

accessMode: QueueAccessMode

Une des valeurs QueueAccessMode.

S’applique à

Partager via

MessageQueue Constructeurs

Définition

Surcharges

MessageQueue()

Exemples

Remarques

Voir aussi

S’applique à

MessageQueue(String)

Paramètres

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

MessageQueue(String, Boolean)

Paramètres

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

MessageQueue(String, QueueAccessMode)

Paramètres

S’applique à

MessageQueue(String, Boolean, Boolean)

Paramètres

Exemples

S’applique à

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Paramètres

S’applique à

Ressources supplémentaires