MessageQueue Konstruktoren

Referenz

Definition

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Initialisiert eine neue Instanz der MessageQueue-Klasse.

Überlädt

MessageQueue()	Initialisiert eine neue Instanz der MessageQueue-Klasse. Nachdem der parameterlose Konstruktor die neue Instanz initialisiert hat, müssen Sie die Path-Eigenschaft der Instanz festlegen, bevor Sie die Instanz verwenden können.
MessageQueue(String)	Initialisiert eine neue Instanz der MessageQueue-Klasse, die auf die Message Queuing-Warteschlange am angegebenen Pfad verweist.
MessageQueue(String, Boolean)	Initialisiert eine neue Instanz der MessageQueue-Klasse mit der angegebenen Lesezugriffsbeschränkung, die auf die Message Queuing-Warteschlange unter dem angegebenen Pfad verweist.
MessageQueue(String, QueueAccessMode)	Initialisiert eine neue Instanz der MessageQueue-Klasse.
MessageQueue(String, Boolean, Boolean)	Initialisiert eine neue Instanz der MessageQueue-Klasse.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	Initialisiert eine neue Instanz der MessageQueue-Klasse.

MessageQueue()

Initialisiert eine neue Instanz der MessageQueue-Klasse. Nachdem der parameterlose Konstruktor die neue Instanz initialisiert hat, müssen Sie die Path-Eigenschaft der Instanz festlegen, bevor Sie die Instanz verwenden können.

public:
 MessageQueue();

public MessageQueue ();

Public Sub New ()

Beispiele

Im folgenden Codebeispiel wird ein neues MessageQueueerstellt.

// 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";

Hinweise

Verwenden Sie diese Überladung, um eine neue instance der Klasse zu erstellen, die MessageQueue nicht sofort an eine Warteschlange auf dem Message Queuing-Server gebunden ist. Bevor Sie diese instance verwenden, müssen Sie sie mit einer vorhandenen Message Queuing-Warteschlange verbinden, indem Sie die Path -Eigenschaft festlegen. Alternativ können Sie den MessageQueue Verweis auf den Rückgabewert der Create(String) Methode festlegen und so eine neue Message Queuing-Warteschlange erstellen.

Der MessageQueue Konstruktor instanziiert eine neue instance der MessageQueue -Klasse. Er erstellt keine neue Message Queuing-Warteschlange.

Die folgende Tabelle zeigt die anfänglichen Eigenschaftswerte für eine instance von MessageQueue.

Eigenschaft	Anfangswert
DefaultPropertiesToSend	Die vom parameterlosen Konstruktor der DefaultPropertiesToSend -Klasse festgelegten Werte.
Formatter	XmlMessageFormatter
MessageReadPropertyFilter	Die vom parameterlosen Konstruktor der MessagePropertyFilter -Klasse festgelegten Werte. Alle Filterwerte sind auf `true`festgelegt.
DenySharedReceive	`false`

Weitere Informationen

Gilt für:

MessageQueue(String)

Initialisiert eine neue Instanz der MessageQueue-Klasse, die auf die Message Queuing-Warteschlange am angegebenen Pfad verweist.

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

public MessageQueue (string path);

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

Public Sub New (path As String)

Parameter

path: String

Der Speicherort der Warteschlange, auf die diese MessageQueue verweist.

Ausnahmen

ArgumentException

Die Path-Eigenschaft ist ungültig. Möglicherweise wurde sie nicht festgelegt.

Beispiele

Im folgenden Codebeispiel werden neue MessageQueue Objekte mit verschiedenen Pfadnamensyntaxtypen erstellt. In jedem Fall wird eine Nachricht an die Warteschlange gesendet, deren Pfad im Konstruktor definiert ist.

#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

Verwenden Sie diese Überladung, wenn Sie die neue MessageQueue instance an eine bestimmte Message Queuing-Warteschlange binden möchten, für die Sie den Pfad, den Formatnamen oder die Bezeichnung kennen. Wenn Sie der ersten Anwendung, die auf die Warteschlange verweist, exklusiven Zugriff gewähren möchten, müssen Sie die DenySharedReceive -Eigenschaft auf true festlegen oder den Konstruktor verwenden, der einen Parameter für die Lesezugriffseinschränkung übergibt.

Der MessageQueue Konstruktor instanziiert eine neue instance der MessageQueue -Klasse. Er erstellt keine neue Message Queuing-Warteschlange. Verwenden Sie Create(String)zum Erstellen einer neuen Warteschlange in Message Queuing .

Die Syntax des path Parameters hängt vom Typ der Warteschlange ab, auf die er verweist, wie in der folgenden Tabelle gezeigt.

Warteschlangentyp	Syntax
Öffentliche Warteschlange	`MachineName`\`QueueName`
Private Warteschlange	`MachineName`\`Private$`\`QueueName`
Journalwarteschlange	`MachineName`\`QueueName`\`Journal$`
Maschinenjournalwarteschlange	`MachineName`\`Journal$`
Warteschlange für unzustellbare Nachrichten für Computer	`MachineName`\`Deadletter$`
Warteschlange für computertransaktionelle Unzustellbare Nachrichten	`MachineName`\`XactDeadletter$`

Alternativ können Sie oder FormatName Label verwenden, um den Warteschlangenpfad zu beschreiben, wie in der folgenden Tabelle gezeigt.

Verweis	Syntax	Beispiel
Formatname	`FormatName:` [ Formatname ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress`\`QueueName` `FormatName:DIRECT=OS:` `MachineName`\`QueueName`
Bezeichnung	`Label:` [ Bezeichnung ]	`Label:` TheLabel

Um offline zu arbeiten, müssen Sie die Formatnamensyntax und nicht die Pfadnamensyntax für den Konstruktor verwenden. Andernfalls wird eine Ausnahme ausgelöst, da der primäre Domänencontroller nicht verfügbar ist, um den Pfad in den Formatnamen aufzulösen.

Die folgende Tabelle zeigt die anfänglichen Eigenschaftswerte für eine instance von MessageQueue. Diese Werte basieren auf den Eigenschaften der Message Queuing-Warteschlange mit dem durch den path Parameter angegebenen Pfad.

Eigenschaft	Anfangswert
Authenticate	`false`
BasePriority	0
Category	Empty
DefaultPropertiesToSend	Die vom parameterlosen Konstruktor der DefaultPropertiesToSend -Klasse festgelegten Werte.
EncryptionRequired	`true`, wenn die Einstellung für die Datenschutzebene der Message Queuing-Warteschlange "Text" lautet; `false`andernfalls .
Formatter	XmlMessageFormatter
Label	Empty
MachineName	Der Wert der Computernameneigenschaft der Message Queuing-Warteschlange.
MaximumJournalSize	InfiniteQueueSize
MaximumQueueSize	InfiniteQueueSize
MessageReadPropertyFilter	Die vom parameterlosen Konstruktor der MessagePropertyFilter -Klasse festgelegten Werte.
Path	Empty, wenn nicht vom Konstruktor festgelegt.
QueueName	Empty, wenn nicht vom Konstruktor festgelegt.
DenySharedReceive	`false`
UseJournalQueue	`true`, wenn die Journaleinstellung des Message Queuing-Objekts aktiviert ist; `false`andernfalls .

Weitere Informationen

Gilt für:

MessageQueue(String, Boolean)

Initialisiert eine neue Instanz der MessageQueue-Klasse mit der angegebenen Lesezugriffsbeschränkung, die auf die Message Queuing-Warteschlange unter dem angegebenen Pfad verweist.

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)

Parameter

path: String

Der Speicherort der Warteschlange, auf die diese MessageQueue verweist. Dieser kann für den lokalen Computer "." lauten.

sharedModeDenyReceive: Boolean

true, wenn der ersten Anwendung, die auf die Warteschlange zugreift, exklusiver Zugriff gewährt werden soll, andernfalls false.

Ausnahmen

ArgumentException

Die Path-Eigenschaft ist ungültig. Möglicherweise wurde sie nicht festgelegt.

Beispiele

Im folgenden Codebeispiel wird ein neues MessageQueue mit exklusivem Zugriff erstellt, dessen Pfad festgelegt und eine Nachricht an die Warteschlange gesendet.

#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.
            myNewQueue.GetExclusiveAccess();
                        
            return;
        }

        //**************************************************
        // Requests exlusive read access to the queue. If
        // access is granted, receives a message from the
        // queue.
        //**************************************************
        
        public 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

Hinweise

Verwenden Sie diese Überladung, wenn Sie die neue MessageQueue an eine bestimmte Message Queuing-Warteschlange binden möchten, für die Sie den Pfad, den Formatnamen oder die Bezeichnung kennen. Wenn Sie der ersten Anwendung, die auf die Warteschlange verweist, exklusiven Zugriff gewähren möchten, legen Sie den sharedModeDenyReceive Parameter auf fest true. Legen Sie sharedModeDenyReceive andernfalls auf false den Konstruktor fest, der nur über einen path Parameter verfügt, oder verwenden Sie diesen.

Die Einstellung sharedModeDenyReceive auf true wirkt sich auf alle Objekte aus, die auf die Message Queuing-Warteschlange zugreifen, einschließlich anderer Anwendungen. Die Auswirkungen des Parameters sind nicht auf diese Anwendung beschränkt.

Der MessageQueue Konstruktor erstellt eine neue instance der MessageQueue -Klasse. Er erstellt keine neue Message Queuing-Warteschlange. Verwenden Sie Create(String)zum Erstellen einer neuen Warteschlange in Message Queuing .

Die Syntax des path Parameters hängt vom Typ der Warteschlange ab.

Warteschlangentyp	Syntax
Öffentliche Warteschlange	`MachineName`\`QueueName`
Private Warteschlange	`MachineName`\`Private$`\`QueueName`
Journalwarteschlange	`MachineName`\`QueueName`\`Journal$`
Maschinenjournalwarteschlange	`MachineName`\`Journal$`
Warteschlange für unzustellbare Nachrichten für Computer	`MachineName`\`Deadletter$`
Warteschlange für computertransaktionelle Unzustellbare Nachrichten	`MachineName`\`XactDeadletter$`

Alternativ können Sie den Formatnamen oder die Bezeichnung einer Message Queuing-Warteschlange verwenden, um den Warteschlangenpfad zu beschreiben.

Verweis	Syntax	Beispiel
Formatname	`FormatName:` [ Formatname ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress`\`QueueName` `FormatName:DIRECT=OS:` `MachineName`\`QueueName`
Bezeichnung	`Label:` [ Bezeichnung ]	`Label:` TheLabel

Um offline zu arbeiten, müssen Sie die Formatnamensyntax anstelle der Anzeigenamensyntax verwenden. Andernfalls wird eine Ausnahme ausgelöst, da der primäre Domänencontroller (auf dem sich Active Directory befindet) nicht verfügbar ist, um den Pfad in den Formatnamen aufzulösen.

Wenn eine MessageQueue eine Warteschlange öffnet, wobei der sharedModeDenyReceive Parameter auf truefestgelegt ist, generiert jeder MessageQueue , der anschließend versucht, aus der Warteschlange zu lesen, eine MessageQueueException aufgrund einer Freigabeverletzung. Ein MessageQueueException wird auch ausgelöst, wenn ein MessageQueue versucht, im exklusiven Modus auf die Warteschlange zuzugreifen, während ein anderer MessageQueue bereits über nicht exklusiven Zugriff auf die Warteschlange verfügt.

In der folgenden Tabelle sind die anfänglichen Eigenschaftswerte für eine instance von MessageQueueaufgeführt. Diese Werte basieren auf den Eigenschaften der Message Queuing-Warteschlange, wobei der Pfad durch den path Parameter angegeben wird.

Eigenschaft	Anfangswert
Authenticate	`false`.
BasePriority	0.
Category	Empty.
DefaultPropertiesToSend	Die vom parameterlosen Konstruktor der DefaultPropertiesToSend -Klasse festgelegten Werte.
EncryptionRequired	`true`, wenn die Einstellung für die Datenschutzebene der Message Queuing-Warteschlange "Body" lautet; `false`andernfalls .
Formatter	XmlMessageFormatter.
Label	Empty.
MachineName	Der Wert der Eigenschaft "Computername" der Message Queuing-Warteschlange.
MaximumJournalSize	InfiniteQueueSize.
MaximumQueueSize	InfiniteQueueSize.
MessageReadPropertyFilter	Die vom parameterlosen Konstruktor der MessagePropertyFilter -Klasse festgelegten Werte.
Path	Empty, wenn nicht vom Konstruktor festgelegt.
QueueName	Empty, wenn nicht vom Konstruktor festgelegt.
DenySharedReceive	Der Wert des `sharedModeDenyReceive`-Parameters.
UseJournalQueue	`true`, wenn die Journaleinstellung des Message Queuing-Objekts aktiviert ist; `false`andernfalls .

Weitere Informationen

Gilt für:

MessageQueue(String, QueueAccessMode)

Initialisiert eine neue Instanz der MessageQueue-Klasse.

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)

Parameter

path: String

Der Speicherort der Warteschlange, auf die diese MessageQueue verweist. Dieser kann für den lokalen Computer "." lauten.

accessMode: QueueAccessMode

Einer der QueueAccessMode-Werte.

Gilt für:

MessageQueue(String, Boolean, Boolean)

Initialisiert eine neue Instanz der MessageQueue-Klasse.

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)

Parameter

path: String

Der Speicherort der Warteschlange, auf die diese MessageQueue verweist. Dieser kann für den lokalen Computer "." lauten.

sharedModeDenyReceive: Boolean

true, wenn der ersten Anwendung, die auf die Warteschlange zugreift, exklusiver Zugriff gewährt werden soll, andernfalls false.

enableCache: Boolean

true, wenn ein Verbindungscache erstellt und verwendet wird, andernfalls false.

Beispiele

Im folgenden Codebeispiel wird ein neues MessageQueue mit exklusivem Lesezugriff und aktivierter Verbindungszwischenspeicherung erstellt.

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

Gilt für:

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Initialisiert eine neue Instanz der MessageQueue-Klasse.

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)

Parameter

path: String

Der Speicherort der Warteschlange, auf die diese MessageQueue verweist. Dieser kann für den lokalen Computer "." lauten.

sharedModeDenyReceive: Boolean

true, wenn der ersten Anwendung, die auf die Warteschlange zugreift, exklusiver Zugriff gewährt werden soll, andernfalls false.

enableCache: Boolean

true, wenn ein Verbindungscache erstellt und verwendet wird, andernfalls false.

accessMode: QueueAccessMode

Einer der QueueAccessMode-Werte.

Gilt für:

MessageQueue Konstruktoren

Definition

Überlädt

MessageQueue()

Beispiele

Hinweise

Weitere Informationen

Gilt für:

MessageQueue(String)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

MessageQueue(String, Boolean)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

MessageQueue(String, QueueAccessMode)

Parameter

Gilt für:

MessageQueue(String, Boolean, Boolean)

Parameter

Beispiele

Gilt für:

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Parameter

Gilt für:

Zusätzliche Ressourcen