MessageQueue Klasse

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.

Ermöglicht den Zugriff auf eine Warteschlange auf einem Message Queuing-Server.

public ref class MessageQueue : System::ComponentModel::Component, System::Collections::IEnumerable

[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
public 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

[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
type MessageQueue = class
    inherit Component
    interface IEnumerable

[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
[<System.Messaging.MessagingDescription("MessageQueueDesc")>]
type MessageQueue = class
    inherit Component
    interface IEnumerable

Public Class MessageQueue
Inherits Component
Implements IEnumerable

Vererbung: Object

MarshalByRefObject

Component
MessageQueue

Attribute: TypeConverterAttribute MessagingDescriptionAttribute

Implementiert: IEnumerable

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

Das folgende Codebeispiel sendet eine Nachricht an eine Warteschlange und empfängt eine Nachricht von einer Warteschlange, wobei eine anwendungsspezifische Klasse namens verwendet wird 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

Hinweise

Die Message Queuing-Technologie ermöglicht es Anwendungen, die zu unterschiedlichen Zeiten ausgeführt werden, über heterogene Netzwerke und Systeme hinweg zu kommunizieren, die vorübergehend offline sind. Anwendungen senden Nachrichten aus Warteschlangen, empfangen oder anzeigen (lesen, ohne sie zu entfernen). Message Queuing ist eine optionale Komponente von Windows 2000 und Windows NT und muss separat installiert werden.

Die MessageQueue -Klasse ist ein Wrapper um Message Queuing. Es gibt mehrere Versionen von Message Queuing, und die Verwendung der MessageQueue -Klasse kann zu einem geringfügig unterschiedlichen Verhalten führen, je nachdem, welches Betriebssystem Sie verwenden.

Die MessageQueue -Klasse stellt einen Verweis auf eine Message Queuing-Warteschlange bereit. Sie können einen Pfad im MessageQueue Konstruktor angeben, um eine Verbindung mit einer vorhandenen Ressource herzustellen, oder Sie können eine neue Warteschlange auf dem Server erstellen. Bevor Sie , Peekoder Receiveaufrufen Send(Object)können, müssen Sie die neue instance der MessageQueue Klasse einer vorhandenen Warteschlange zuordnen. An diesem Punkt können Sie die Warteschlangeneigenschaften wie Category und Labelbearbeiten.

MessageQueue unterstützt zwei Arten des Nachrichtenabrufs: synchron und asynchron. Die synchronen Methoden und Receiveführen dazu, dass der Prozessthread ein angegebenes Zeitintervall wartet, Peek bis eine neue Nachricht in der Warteschlange eintrifft. Mit den asynchronen Methoden BeginPeek und BeginReceivekönnen die Standard Anwendungstasks in einem separaten Thread fortgesetzt werden, bis eine Nachricht in der Warteschlange eingeht. Diese Methoden funktionieren mithilfe von Rückrufobjekten und Zustandsobjekten, um Informationen zwischen Threads zu kommunizieren.

Wenn Sie eine neue instance der MessageQueue -Klasse erstellen, erstellen Sie keine neue Message Queuing-Warteschlange. Stattdessen können Sie die Create(String)Methoden , Delete(String)und Purge verwenden, um Warteschlangen auf dem Server zu verwalten.

Im Gegensatz zu Purgesind Create(String) und Delete(String)static Member, sodass Sie sie aufrufen können, ohne eine neue instance der MessageQueue -Klasse zu erstellen.

Sie können die MessageQueue -Eigenschaft des Path Objekts mit einem von drei Namen festlegen: dem Anzeigenamen, dem FormatNameoder dem Label. Der Anzeigename, der durch die Eigenschaften und eigenschaften der Warteschlange MachineName definiert wird, ist MachineName\QueueName für eine öffentliche Warteschlange undPrivate$QueueName MachineName\\für eine private Warteschlange.QueueName Die FormatName -Eigenschaft ermöglicht den Offlinezugriff auf Nachrichtenwarteschlangen. Schließlich können Sie die Eigenschaft der Warteschlange Label verwenden, um die -Eigenschaft der Warteschlange Pathfestzulegen.

Eine Liste der anfänglichen Eigenschaftswerte für eine instance von MessageQueuefinden Sie im MessageQueue Konstruktor.

Konstruktoren

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, Boolean, Boolean)	Initialisiert eine neue Instanz der MessageQueue-Klasse.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	Initialisiert eine neue Instanz der MessageQueue-Klasse.
MessageQueue(String, QueueAccessMode)	Initialisiert eine neue Instanz der MessageQueue-Klasse.

Felder

InfiniteQueueSize	Legt fest, dass für eine Warteschlange keine Größenbeschränkung besteht.
InfiniteTimeout	Gibt an, dass für Methoden, die Meldungen einsehen oder empfangen, kein Timeout festgelegt ist.

Eigenschaften

AccessMode	Ruft einen Wert ab, der den Zugriffsmodus für die Warteschlange angibt.
Authenticate	Ruft einen Wert ab, der angibt, ob die Warteschlange nur authentifizierte Meldungen akzeptiert, oder legt diesen fest.
BasePriority	Gibt die Basispriorität an, die von Message Queuing beim Weiterleiten von Meldungen einer öffentlichen Warteschlange über das Netzwerk verwendet wird, oder legt diese fest.
CanRaiseEvents	Ruft einen Wert ab, der angibt, ob die Komponente ein Ereignis auslösen kann. (Geerbt von Component)
CanRead	Ruft einen Wert ab, der angibt, ob die MessageQueue gelesen werden kann.
CanWrite	Ruft einen Wert ab, der angibt, ob in die MessageQueue geschrieben werden kann.
Category	Ruft die Kategorie der Warteschlange ab oder legt diese fest.
Container	Ruft die IContainer ab, die in der Component enthalten ist. (Geerbt von Component)
CreateTime	Ruft Zeit und Datum der Erstellung der Warteschlange in Message Queuing ab.
DefaultPropertiesToSend	Ruft die Eigenschaftswerte für Meldungen ab, die beim Senden einer Meldung an die Warteschlange standardmäßig verwendet werden.
DenySharedReceive	Ruft einen Wert ab, der angibt, ob diese MessageQueue über exklusive Zugriffsrechte für das Empfangen von Meldungen aus der Message Queuing-Warteschlange verfügt, oder legt diesen fest.
DesignMode	Ruft einen Wert ab, der angibt, ob sich Component gegenwärtig im Entwurfsmodus befindet. (Geerbt von Component)
EnableConnectionCache	Ruft einen Wert ab, der angibt, ob die Anwendung einen Verbindungscache verwaltet, oder legt diesen fest.
EncryptionRequired	Ruft einen Wert ab, der angibt, ob die Warteschlange lediglich nicht private (nicht verschlüsselte) Meldungen akzeptiert, oder legt diesen fest.
Events	Ruft die Liste der Ereignishandler ab, die dieser Component angefügt sind. (Geerbt von Component)
FormatName	Ruft den eindeutigen Namen der Warteschlange ab, den Message Queuing beim Erstellen der Warteschlange erzeugt hat.
Formatter	Ruft das Formatierungsprogramm ab, oder legt das Formatierungsprogramm fest, das zum Serialisieren und Deserialisieren eines Objekts in bzw. aus dem Körper einer Meldung verwendet wird, die aus einer Warteschlange gelesen oder in eine Warteschlange geschrieben wird.
Id	Ruft den eindeutigen Message Queuing-Bezeichner für die Warteschlange ab.
Label	Ruft die Beschreibung der Warteschlange ab oder legt diese fest.
LastModifyTime	Ruft den Zeitpunkt ab, zu dem die Eigenschaften einer Warteschlange zuletzt geändert wurden.
MachineName	Ruft den Namen des Computers ab, auf dem sich die Message Queuing-Warteschlange befindet, oder legt diesen fest.
MaximumJournalSize	Ruft die maximale Größe der Journalwarteschlange ab oder legt diese fest.
MaximumQueueSize	Ruft die maximale Größe der Warteschlange ab oder legt diese fest.
MessageReadPropertyFilter	Ruft den Eigenschaftenfilter für das Empfangen oder Einsehen von Meldungen ab oder legt diesen fest.
MulticastAddress	Eingeführt in MSMQ 3.0. Ruft die der Warteschlange zugeordnete Multicastadresse ab oder oder legt diese fest.
Path	Ruft den Pfad der Warteschlange ab oder legt diesen fest. Nach dem Festlegen des Path zeigt die MessageQueue auf eine neue Warteschlange.
QueueName	Ruft den angezeigten Namen für die Warteschlange ab oder legt diesen fest.
ReadHandle	Ruft das systemeigene Handle zum Empfangen von Meldungen aus der Meldungswarteschlange ab.
Site	Ruft den ISite von Component ab oder legt ihn fest. (Geerbt von Component)
SynchronizingObject	Ruft das Objekt ab, das den durch ein ReceiveCompleted-Ereignis oder ein PeekCompleted-Ereignis ausgelösten Ereignishandleraufruf marshallt, oder legt diesen fest.
Transactional	Ruft einen Wert ab, der angibt, ob die Warteschlange nur Transaktionen akzeptiert.
UseJournalQueue	Ruft einen Wert ab, der angibt, ob abgerufene Meldungen in die Journalwarteschlange kopiert werden, oder legt diesen fest.
WriteHandle	Das systemeigene Handle zum Senden von Meldungen an die Meldungswarteschlange.

Methoden

BeginPeek()	Diese Methode initiiert einen asynchronen Einsehvorgang ohne Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist.
BeginPeek(TimeSpan)	Diese Methode initiiert einen asynchronen Einsehvorgang mit einem bestimmten Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist oder ein Timeout auftritt.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Initiiert einen asynchronen Lesevorgang, der über einen angegebenen Timeout verfügt und für den ein Cursor, eine Suchaktion und ein Zustandsobjekt festgelegt sind. Das Zustandsobjekt stellt für die Lebensdauer des Vorgangs zugeordnete Informationen bereit. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.
BeginPeek(TimeSpan, Object)	Initiiert einen asynchronen Lesevorgang mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.
BeginPeek(TimeSpan, Object, AsyncCallback)	Initiiert einen asynchronen Lesevorgang mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.
BeginReceive()	Diese Methode initiiert einen asynchronen Empfangsvorgang ohne Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist.
BeginReceive(TimeSpan)	Diese Methode initiiert einen asynchronen Empfangsvorgang mit einem bestimmten Timeout. Der Vorgang ist erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist oder ein Timeout auftritt.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	Initiiert einen asynchronen Receive-Vorgang, der über einen angegebenen Timeout verfügt und für den ein Cursor und ein Zustandsobjekt festgelegt sind. Das Zustandsobjekt stellt für die Lebensdauer des Vorgangs zugeordnete Informationen bereit. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.
BeginReceive(TimeSpan, Object)	Initiiert eine asynchrone Receive-Methode mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.
BeginReceive(TimeSpan, Object, AsyncCallback)	Initiiert eine asynchrone Receive-Methode mit einem angegebenen Timeout und einem angegebenen Zustandsobjekt, das während der Lebensdauer des Vorgangs Informationen für den Vorgang bereitstellt. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.
ClearConnectionCache()	Löscht den Verbindungscache.
Close()	Gibt alle von der MessageQueue reservierten Ressourcen frei.
Create(String)	Erstellt eine nicht transaktionale Message Queuing-Warteschlange unter dem angegebenen Pfad.
Create(String, Boolean)	Erstellt eine transaktionale oder eine nicht transaktionale Message Queuing-Warteschlange unter dem angegebenen Pfad.
CreateCursor()	Erstellt einen neuen Cursor für die aktuelle Meldungswarteschlange.
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
Delete(String)	Löschte eine Warteschlange auf einem Message Queuing-Server.
Dispose()	Gibt alle vom Component verwendeten Ressourcen frei. (Geerbt von Component)
Dispose(Boolean)	Gibt die von der MessageQueue-Klasse verwendeten Ressourcen (mit Ausnahme des Speichers) frei.
EndPeek(IAsyncResult)	Schließt den angegebenen asynchronen Lesevorgang ab.
EndReceive(IAsyncResult)	Schließt die angegebene asynchrone Receive-Methode ab.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
Exists(String)	Bestimmt, ob unter dem angegeben Pfad eine Message Queuing-Warteschlange vorhanden ist.
GetAllMessages()	Gibt alle Meldungen in der Warteschlange zurück.
GetEnumerator()	Veraltet. Listet die Meldungen in einer Warteschlange auf. GetEnumerator() ist veraltet. GetMessageEnumerator2() sollte stattdessen verwendet werden.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetMachineId(String)	Ruft den Computerbezeichner ab, auf dem sich die Warteschlange befindet, auf die diese MessageQueue verweist.
GetMessageEnumerator()	Veraltet. Erstellt ein Enumerationsobjekt für alle Meldungen in der Warteschlange. GetMessageEnumerator() ist veraltet. GetMessageEnumerator2() sollte stattdessen verwendet werden.
GetMessageEnumerator2()	Erstellt ein Enumerationsobjekt für alle Meldungen in der Warteschlange.
GetMessageQueueEnumerator()	Stellt eine Vorwärts-Cursorsemantik zum Durchlaufen aller öffentlichen Warteschlangen im Netzwerk bereit.
GetMessageQueueEnumerator(MessageQueueCriteria)	Stellt eine Vorwärts-Cursorsemantik zum Durchlaufen aller öffentlichen Warteschlangen im Netzwerk bereit, die die angegebenen Kriterien erfüllen.
GetPrivateQueuesByMachine(String)	Ruft alle privaten Warteschlangen auf dem angegebenen Computer ab.
GetPublicQueues()	Ruft alle öffentlichen Warteschlangen im Netzwerk ab.
GetPublicQueues(MessageQueueCriteria)	Ruft alle öffentlichen Warteschlangen im Netzwerk ab, die die angegebenen Kriterien erfüllen.
GetPublicQueuesByCategory(Guid)	Ruft alle öffentlichen Warteschlangen im Netzwerk ab, die der angegebenen Kategorie angehören.
GetPublicQueuesByLabel(String)	Ruft alle öffentlichen Warteschlangen im Netzwerk ab, die die angegebene Bezeichnung aufweisen.
GetPublicQueuesByMachine(String)	Ruft alle öffentlichen Warteschlangen auf dem angegebenen Computer ab.
GetSecurityContext()	Ruft den Sicherheitskontext ab, den MSMQ zum Zeitpunkt des Aufrufs dem aktuellen Benutzer zuordnet (Threadidentität).
GetService(Type)	Gibt ein Objekt zurück, das einen von der Component oder von deren Container bereitgestellten Dienst darstellt. (Geerbt von Component)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
Peek()	Wird beendet, ohne die erste Meldung in der Warteschlange zu entfernen (einzusehen), auf die diese MessageQueue verweist. Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread bis zum Eingang einer Meldung.
Peek(TimeSpan)	Wird beendet, ohne die erste Meldung in der Warteschlange zu entfernen (einzusehen), auf die diese MessageQueue verweist. Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread, bis eine Meldung verfügbar wird oder der Timeout eintritt.
Peek(TimeSpan, Cursor, PeekAction)	Wird beendet, ohne die aktuelle oder die nächste Meldung mithilfe des angegebenen Cursors zu entfernen (einzusehen). Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread, bis eine Meldung verfügbar wird oder der Timeout eintritt.
PeekByCorrelationId(String)	Sieht die Meldung mit der angegebenen Korrelations-ID ein und löst sofort eine Ausnahme aus, wenn in der Warteschlange derzeit keine Meldung mit der angegebenen Korrelations-ID vorhanden ist.
PeekByCorrelationId(String, TimeSpan)	Sieht eine Meldung mit der angegebenen Korrelations-ID ein und wartet, bis eine Meldung mit der angegebenen Korrelations-ID in der Warteschlange verfügbar ist oder bis der Timeout abläuft.
PeekById(String)	Sieht die Meldung ein, deren Meldungs-ID mit dem `id`-Parameter übereinstimmt.
PeekById(String, TimeSpan)	Sieht die Meldung ein, deren Meldungs-ID mit dem `id`-Parameter übereinstimmt. Wartet, bis die Meldung in der Warteschlange eingeht oder ein Timeout auftritt.
PeekByLookupId(Int64)	Eingeführt in MSMQ 3.0. Sieht die Meldung ein, die dem angegebenen Suchbezeichner in einer nicht transaktionalen Warteschlange entspricht.
PeekByLookupId(MessageLookupAction, Int64)	Eingeführt in MSMQ 3.0. Sieht eine bestimmte Meldung in der Warteschlange ein. Die Meldung kann anhand eines Suchbezeichners oder anhand der Position am Anfang oder am Ende der Warteschlange angegeben werden.
Purge()	Löscht alle in der Warteschlange enthaltenen Meldungen.
Receive()	Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.
Receive(MessageQueueTransaction)	Empfängt die erste verfügbare Meldung aus der transaktionalen Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.
Receive(MessageQueueTransactionType)	Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.
Receive(TimeSpan)	Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist, und wartet, bis eine Meldung in der Warteschlange verfügbar ist oder das Timeout abläuft.
Receive(TimeSpan, Cursor)	Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.
Receive(TimeSpan, MessageQueueTransaction)	Empfängt die erste verfügbare Meldung aus der transaktionalen Warteschlange, auf die die MessageQueue verweist, und wartet, bis eine Meldung in der Warteschlange verfügbar ist oder das Timeout abläuft.
Receive(TimeSpan, MessageQueueTransactionType)	Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist. Dieser Aufruf ist synchron und wartet, bis entweder eine Meldung in der Warteschlange verfügbar ist oder der Timeout abläuft.
ReceiveByCorrelationId(String)	Empfängt die Meldung mit der angegebenen Korrelations-ID (aus einer nicht transaktionalen Warteschlange) und löst sofort eine Ausnahme aus, wenn sich derzeit keine Meldung mit der angegebenen Korrelations-ID in der Warteschlange befindet.
ReceiveByCorrelationId(String, MessageQueueTransaction)	Empfängt die Meldung mit der angegebenen Korrelations-ID (aus einer transaktionalen Warteschlange) und löst sofort eine Ausnahme aus, wenn sich derzeit keine Meldung mit der angegebenen Korrelations-ID in der Warteschlange befindet.
ReceiveByCorrelationId(String, MessageQueueTransactionType)	Empfängt die Meldung mit der angegebenen Korrelations-ID und löst sofort eine Ausnahme aus, wenn sich derzeit keine Meldung mit der angegebenen Korrelations-ID in der Warteschlange befindet.
ReceiveByCorrelationId(String, TimeSpan)	Empfängt die Meldung mit der angegebenen Korrelations-ID (aus einer nicht transaktionalen Warteschlange) und wartet, bis eine Meldung mit der angegebenen Korrelations-ID in der Warteschlange verfügbar ist oder das Timeout abläuft.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)	Empfängt die Meldung mit der angegebenen Korrelations-ID (aus einer transaktionalen Warteschlange) und wartet, bis eine Meldung mit der angegebenen Korrelations-ID in der Warteschlange verfügbar ist oder das Timeout abläuft.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)	Empfängt die Meldung mit der angegebenen Korrelations-ID und wartet, bis eine Meldung mit der angegebenen Korrelations-ID in der Warteschlange verfügbar ist oder das Timeout abläuft.
ReceiveById(String)	Empfängt die Meldung mit der angegebenen ID aus einer nicht transaktionalen Warteschlange und löst sofort eine Ausnahme aus, wenn sich derzeit keine Meldung mit der angegebenen ID in der Warteschlange befindet.
ReceiveById(String, MessageQueueTransaction)	Empfängt die Meldung mit der angegebenen ID (aus einer transaktionalen Warteschlange) und löst sofort eine Ausnahme aus, wenn sich derzeit keine Meldung mit der angegebenen ID in der Warteschlange befindet.
ReceiveById(String, MessageQueueTransactionType)	Empfängt die Meldung mit der angegebenen ID und löst sofort eine Ausnahme aus, wenn sich derzeit keine Meldung mit der angegebenen ID in der Warteschlange befindet.
ReceiveById(String, TimeSpan)	Empfängt die Meldung mit der angegebenen ID (aus einer nicht transaktionalen Warteschlange) und wartet, bis eine Meldung mit der angegebenen ID in der Warteschlange verfügbar ist oder das Timeout abläuft.
ReceiveById(String, TimeSpan, MessageQueueTransaction)	Empfängt die Meldung mit der angegebenen ID (aus einer transaktionalen Warteschlange) und wartet, bis eine Meldung mit der angegebenen ID in der Warteschlange verfügbar ist oder das Timeout abläuft.
ReceiveById(String, TimeSpan, MessageQueueTransactionType)	Empfängt die Meldung mit der angegebenen ID und wartet, bis eine Meldung mit der angegebenen ID in der Warteschlange verfügbar ist oder das Timeout abläuft.
ReceiveByLookupId(Int64)	Eingeführt in MSMQ 3.0. Empfängt die Meldung, die dem angegebenen Suchbezeichner in einer nicht transaktionalen Warteschlange entspricht.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)	Eingeführt in MSMQ 3.0. Empfängt eine bestimmte Meldung aus einer transaktionalen Warteschlange. Die Meldung kann anhand eines Suchbezeichners oder anhand der Position am Anfang oder am Ende der Warteschlange angegeben werden.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)	Eingeführt in MSMQ 3.0. Empfängt unter Verwendung des angegebenen Transaktionskontexts eine bestimmte Meldung aus der Warteschlange. Die Meldung kann anhand eines Suchbezeichners oder anhand der Position am Anfang oder am Ende der Warteschlange angegeben werden.
Refresh()	Aktualisiert die von der MessageQueue dargestellten Eigenschaften, sodass sie den aktuellen Zustand der Ressource wiedergeben.
ResetPermissions()	Setzt die Berechtigungsliste auf die Standardwerte des Betriebssystems zurück. Entfernt sämtliche Berechtigungen für Warteschlangen, die an die Standardliste angefügt wurden.
Send(Object)	Sendet ein Objekt an die nicht transaktionale Warteschlange, auf die diese MessageQueue verweist.
Send(Object, MessageQueueTransaction)	Sendet ein Objekt an die transaktionale Warteschlange, auf die diese MessageQueue verweist.
Send(Object, MessageQueueTransactionType)	Sendet ein Objekt an die Warteschlange, auf die diese MessageQueue verweist.
Send(Object, String)	Sendet ein Objekt an die nicht transaktionale Warteschlange, auf die diese MessageQueue verweist, und gibt eine Bezeichnung für die Meldung an.
Send(Object, String, MessageQueueTransaction)	Sendet ein Objekt an die transaktionale Warteschlange, auf die diese MessageQueue verweist, und gibt eine Bezeichnung für die Meldung an.
Send(Object, String, MessageQueueTransactionType)	Sendet ein Objekt an die Warteschlange, auf die diese MessageQueue verweist, und gibt eine Bezeichnung für die Meldung an.
SetPermissions(AccessControlList)	Weist der Warteschlange anhand einer Zugriffssteuerungsliste Zugriffsrechte zu.
SetPermissions(MessageQueueAccessControlEntry)	Weist der Warteschlange anhand eines Zugriffssteuerungseintrags Zugriffsrechte zu.
SetPermissions(String, MessageQueueAccessRights)	Gewährt einem Computer, einer Gruppe oder einem Benutzer die angegebenen Zugriffsrechte.
SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType)	Gewährt einem Computer, einer Gruppe oder einem einzelnen Benutzer die angegebenen Zugriffsrechte mit dem angegebenen Zugriffssteuerungstyp (Zulassen, Verweigern, Widerrufen oder Festlegen).
ToString()	Gibt einen String zurück, der den Namen der Component enthält (sofern vorhanden). Diese Methode darf nicht überschrieben werden. (Geerbt von Component)

Ereignisse

Disposed	Tritt auf, wenn die Komponente von einem Aufruf der Dispose()-Methode verworfen wird. (Geerbt von Component)
PeekCompleted	Tritt ein, wenn eine Meldung gelesen wird, ohne sie aus der Warteschlange zu entfernen. Dies ist ein Ergebnis eines asynchronen BeginPeek()-Vorgangs.
ReceiveCompleted	Tritt ein, wenn eine Meldung aus der Warteschlange entfernt wurde. Dieses Ereignis wird von dem asynchronen BeginReceive()-Vorgang ausgelöst.

Erweiterungsmethoden

Cast<TResult>(IEnumerable)	Wandelt die Elemente eines IEnumerable in den angegebenen Typ um
OfType<TResult>(IEnumerable)	Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs
AsParallel(IEnumerable)	Ermöglicht die Parallelisierung einer Abfrage.
AsQueryable(IEnumerable)	Konvertiert einen IEnumerable in einen IQueryable.

Gilt für:

Threadsicherheit

Nur die GetAllMessages() Methode ist threadsicher.

Freigeben über