MessageQueue.Path Eigenschaft

Definition

Ruft den Pfad der Warteschlange ab oder legt diesen fest.Gets or sets the queue's path. Nach dem Festlegen des Path zeigt die MessageQueue auf eine neue Warteschlange.Setting the Path causes the MessageQueue to point to a new queue.

public:
 property System::String ^ Path { System::String ^ get(); void set(System::String ^ value); };
[System.ComponentModel.Browsable(false)]
[System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.Messaging.MessagingDescription("MQ_Path")]
public string Path { get; set; }
[System.ComponentModel.Browsable(false)]
[System.Messaging.MessagingDescription("MQ_Path")]
[System.ComponentModel.SettingsBindable(true)]
[System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
public string Path { get; set; }
[System.ComponentModel.Browsable(false)]
[System.Messaging.MessagingDescription("MQ_Path")]
[System.ComponentModel.SettingsBindable(true)]
[System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
public string Path { get; set; }
[System.ComponentModel.Browsable(false)]
[System.Messaging.MessagingDescription("MQ_Path")]
[System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
public string Path { get; set; }
[<System.ComponentModel.Browsable(false)>]
[<System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")>]
[<System.Messaging.MessagingDescription("MQ_Path")>]
member this.Path : string with get, set
[<System.ComponentModel.Browsable(false)>]
[<System.Messaging.MessagingDescription("MQ_Path")>]
[<System.ComponentModel.SettingsBindable(true)>]
[<System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")>]
member this.Path : string with get, set
[<System.ComponentModel.Browsable(false)>]
[<System.Messaging.MessagingDescription("MQ_Path")>]
[<System.ComponentModel.SettingsBindable(true)>]
[<System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")>]
member this.Path : string with get, set
[<System.ComponentModel.Browsable(false)>]
[<System.Messaging.MessagingDescription("MQ_Path")>]
[<System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")>]
member this.Path : string with get, set
Public Property Path As String

Eigenschaftswert

String

Die Warteschlange, auf die die MessageQueue verweist.The queue that is referenced by the MessageQueue. Die Standardeinstellung hängt vom verwendeten MessageQueue()-Konstruktor ab. Sie ist entweder null, oder sie wird durch den path-Parameter des Konstruktors angegeben.The default depends on which MessageQueue() constructor you use; it is either null or is specified by the constructor's path parameter.

Attribute

Ausnahmen

Der Pfad ist ungültig. Möglicherweise wurde eine falsche Syntax verwendet.The path is not valid, possibly because the syntax is not valid.

Beispiele

Im folgenden Codebeispiel werden neue- MessageQueue Objekte mithilfe verschiedener Syntax Typen für Pfadnamen erstellt.The following code example creates new MessageQueue objects using various path name syntax types. In jedem Fall sendet Sie eine Nachricht an die Warteschlange, deren Pfad im Konstruktor definiert ist.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

Hinweise

Die Syntax für die- Path Eigenschaft hängt vom Typ der Warteschlange ab, auf die Sie verweist, wie in der folgenden Tabelle dargestellt.The syntax for the Path property depends on the type of queue it points to, as shown in the following table.

WarteschlangentypQueue type SyntaxSyntax
Öffentliche WarteschlangePublic queue MachineName\QueueName
Private WarteschlangePrivate queue MachineName\Private$\QueueName
JournalwarteschlangeJournal queue MachineName\QueueName\Journal$
Computer Journal WarteschlangeMachine journal queue MachineName\Journal$
Warteschlange für unzustellbare NachrichtenMachine dead-letter queue MachineName\Deadletter$
Computer transaktionale Warteschlange für unzustellbare NachrichtenMachine transactional dead-letter queue MachineName\XactDeadletter$

Verwenden Sie ".", um den lokalen Computer darzustellen.Use "." to represent the local computer.

Die MachineName Path Eigenschaften, und QueueName sind miteinander verknüpft.The MachineName, Path, and QueueName properties are related. Das Ändern der MachineName Eigenschaft bewirkt, dass sich die Path Eigenschaft ändert.Changing the MachineName property causes the Path property to change. Sie wird aus dem neuen MachineName und dem erstellt QueueName .It is built from the new MachineName and the QueueName. Wenn Sie ändern (z. b. Path zur Verwendung der Format Namen Syntax), werden die MachineName -Eigenschaft und die-Eigenschaft QueueName auf die neue Warteschlange zurückgesetzt.Changing the Path (for example, to use the format name syntax) resets the MachineName and QueueName properties to refer to the new queue.

Alternativ können Sie oder verwenden, FormatName Label um den Warteschlangen Pfad zu beschreiben, wie in der folgenden Tabelle dargestellt.Alternatively, you can use the FormatName or Label to describe the queue path, as shown in the following table.

ReferenzReference SyntaxSyntax BeispielExample
FormatnameFormat name FormatName: [ Format Name ]FormatName: [ format name ] FormatName:Public= 5a5f 7535-AE9a-41d4-935c-845c2aff7112FormatName:Public= 5A5F7535-AE9A-41d4-935C-845C2AFF7112
BezeichnungLabel Label: [ Bezeichnung ]Label: [ label ] Label: ThelabelLabel: TheLabel

Wenn Sie die Bezeichnungs Syntax für die- Path Eigenschaft verwenden, wenn Sie die Nachricht senden, wird eine Ausnahme ausgelöst, wenn Label nicht eindeutig ist.If you use the label syntax for the Path property when you send the message, an exception will be thrown if the Label is not unique.

Um offline arbeiten zu können, müssen Sie anstelle der Syntax für den anzeigen Amen in der ersten Tabelle die Syntax Format Name verwenden.To work offline, you must use the format name syntax, rather than the friendly name syntax in the first table. Andernfalls wird eine Ausnahme ausgelöst, da der primäre Domänen Controller (auf dem sich Active Directory befindet) nicht verfügbar ist, um den Pfad zum Format Namen aufzulösen.Otherwise, an exception is thrown because the primary domain controller (on which Active Directory resides) is not available to resolve the path to the format name.

Wenn Sie einen neuen Pfad festlegen, wird die Nachrichten Warteschlange geschlossen und alle Handles freigegebenSetting a new path closes the message queue and releases all handles.

In der folgenden Tabelle wird gezeigt, ob diese Eigenschaft in verschiedenen Arbeitsgruppen Modi verfügbar ist.The following table shows whether this property is available in various Workgroup modes.

Arbeitsgruppen ModusWorkgroup mode VerfügbarAvailable
Lokaler ComputerLocal computer JaYes
Name des lokalen Computers und des direkten FormatsLocal computer and direct format name JaYes
Remote ComputerRemote computer JaYes
Name des Remote Computers und des direkten FormatsRemote computer and direct format name JaYes

Hinweis

Im Arbeitsgruppen Modus können Sie nur private Warteschlangen verwenden.In workgroup mode you can only use private queues. Sie geben den Pfad mithilfe der Syntax der privaten Warteschlange an MachineName \ Private$ \ QueueName .You specify the path using the private queue syntax MachineName\Private$\QueueName.

Gilt für:

Weitere Informationen