Cette documentation est archivée et n’est pas conservée.

MessageQueue.Path, propriété

Obtient ou définit le chemin d'accès de la file d'attente. Le paramétrage de Path force MessageQueue à pointer vers une nouvelle file d'attente.

Espace de noms : System.Messaging
Assembly : System.Messaging (dans system.messaging.dll)

public string Path { get; set; }
/** @property */
public String get_Path ()

/** @property */
public void set_Path (String value)

public function get Path () : String

public function set Path (value : String)

Valeur de la propriété

File d'attente référencée par MessageQueue. La valeur par défaut varie en fonction du constructeur MessageQueue utilisé. Elle est égale à référence Null (Nothing en Visual Basic) ou elle est spécifiée par le paramètre path du constructeur.

Type d'exceptionCondition

ArgumentException

Le chemin d'accès n'est pas valide. La syntaxe utilisée est sans doute incorrecte.

La syntaxe de la propriété Path dépend du type de file d'attente vers laquelle elle pointe, comme le montre le tableau suivant.

Type de file d'attente

Syntaxe

File publique

MachineName\QueueName

File privée

MachineName\Private$\QueueName

Journal de file d'attente

MachineName\QueueName\Journal$

Journal de file d'attente de l'ordinateur

MachineName\Journal$

File d'attente de lettres mortes machine

MachineName\Deadletter$

File d'attente de lettres mortes transactionnelle machine

MachineName\XactDeadletter$

Utilisez "." pour représenter l'ordinateur local.

Les propriétés MachineName, Path et QueueName sont liées. La modification de la propriété MachineName engendre la modification de la propriété Path. Elle est créée à partir du nouveau MachineName et de QueueName. La modification de Path (pour utiliser, par exemple, la syntaxe du nom de format) engendre la réinitialisation des propriétés MachineName et QueueName pour faire référence à la nouvelle file d'attente.

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

Référence

Syntaxe

Exemple

Nom de format

FormatName: [ format name ]

FormatName:Public= 5A5F7535-AE9A-41d4-935C-845C2AFF7112

Étiquette

Label: [ label ]

Label: TheLabel

Si vous utilisez la syntaxe de l'étiquette pour la propriété Path lorsque vous envoyez le message, une exception sera levée si Label n'est pas unique.

Pour travailler en mode hors connexion, vous devez utiliser la syntaxe de nom de format et non la syntaxe de nom convivial, telle que répertoriée dans le premier tableau. Sinon, une exception est levée, car le contrôleur principal du domaine (sur lequel Active Directory réside) n'est pas disponible pour résoudre le chemin d'accès en nom de format.

La définition d'un nouveau chemin d'accès ferme la file d'attente de messages et libère tous les handles.

Le tableau suivant montre si cette propriété est disponible dans différents modes groupe de travail.

Mode groupe de travail

Disponible

Ordinateur local

Oui

Ordinateur local et nom de format direct

Oui

Ordinateur distant

Oui

Ordinateur distant et nom de format direct

Oui

Remarque sur la plate-forme Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows CE : Active Directory n'étant pas pris en charge sur les périphériques, le .NET Compact Framework ne peut pas déterminer si une file d'attente distante est transactionnelle. Pour envoyer un message à une file d'attente de transaction distante, ajoutez ;XACTONLY à propriété Path. Pour plus d'informations, consultez MSMQ dans le .NET Compact Framework.

L'exemple de code suivant crée des objets MessageQueue à l'aide de divers types de syntaxes de nom de chemin. 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;
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.
			}
		}

	}
}

package MyProject;

import System.*;
import System.Messaging.*;

/// <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(String[] args)
    {
        // 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;
    } //main

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

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

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

    // 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;
    } //SendByFormatName

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

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

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

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

  • Confiance totale accordée à l'appelant immédiat. Ce membre ne peut pas être utilisé par du code d'un niveau de confiance partiel. Pour plus d'informations, consultez .

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.

.NET Framework

Prise en charge dans : 2.0, 1.1, 1.0

.NET Compact Framework

Prise en charge dans : 2.0
Afficher: