MessageQueue MessageQueue MessageQueue MessageQueue Class

Definition

Ermöglicht den Zugriff auf eine Warteschlange auf einem Message Queuing-Server.Provides access to a queue on a Message Queuing server.

public ref 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
type MessageQueue = class
    inherit Component
    interface IEnumerable
Public Class MessageQueue
Inherits Component
Implements IEnumerable
Vererbung
Attribute
Implementiert

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
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 'Main


        ' References public queues.
        Public Sub SendPublic()

            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Send("Public queue by path name.")

            Return

        End Sub 'SendPublic


        ' References private queues.
        Public Sub SendPrivate()

            Dim myQueue As New MessageQueue(".\Private$\myQueue")
            myQueue.Send("Private queue by path name.")

            Return

        End Sub 'SendPrivate


        ' References queues by label.
        Public Sub SendByLabel()

            Dim myQueue As New MessageQueue("Label:TheLabel")
            myQueue.Send("Queue by label.")

            Return

        End Sub 'SendByLabel


        ' 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 'SendByFormatName


        ' 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 'MonitorComputerJournal


        ' 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 'MonitorQueueJournal


        ' 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 'MonitorDeadLetter


        ' 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 'MonitorTransactionalDeadLetter

End Class 'MyNewQueue 

Im folgenden Codebeispiel wird eine Nachricht an eine Warteschlange gesendet, und es wird eine Nachricht aus einer Warteschlange mit einer anwendungsspezifischen OrderKlasse mit dem Namen empfangen.The following code example sends a message to a queue, and receives a message from a queue, using an application-specific class called 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
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 'Order


   
    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 'Main


        '
        ' 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 'SendMessage


        '
        ' 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 'ReceiveMessage

End Class 'MyNewQueue

Hinweise

Die Message Queuing-Technologie ermöglicht Anwendungen, die zu unterschiedlichen Zeitpunkten ausgeführt werden, über heterogene Netzwerke und Systeme zu kommunizieren, die vorübergehend offline sind.The Message Queuing technology allows applications running at different times to communicate across heterogeneous networks and systems that might be temporarily offline. Anwendungen senden, empfangen oder einsehen (lesen, ohne zu entfernen) Nachrichten aus Warteschlangen.Applications send, receive, or peek (read without removing) messages from queues. Message Queuing ist eine optionale Komponente von Windows 2000Windows 2000 und Windows NT und muss separat installiert werden.Message Queuing is an optional component of Windows 2000Windows 2000 and Windows NT, and must be installed separately.

Die MessageQueue -Klasse ist ein Wrapper um Message Queuing.The MessageQueue class is a wrapper around Message Queuing. Es gibt mehrere Versionen von Message Queuing, und die Verwendung MessageQueue der-Klasse kann in Abhängigkeit vom verwendeten Betriebssystem etwas anderes Verhalten zur Folge haben.There are multiple versions of Message Queuing, and using the MessageQueue class can result in slightly different behavior, depending on the operating system you are using. Informationen zu bestimmten Features der einzelnen Versionen von Message Queuing finden Sie im Thema "What es New in Message Queuing" im Platform SDK in MSDN.For information about specific features of each version of Message Queuing, see the topic "What's New in Message Queuing" in the Platform SDK in MSDN.

Die MessageQueue -Klasse stellt einen Verweis auf eine Message Queuing Warteschlange bereit.The MessageQueue class provides a reference to a Message Queuing queue. 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.You can specify a path in the MessageQueue constructor to connect to an existing resource, or you can create a new queue on the server. Bevor Sie Send(Object) MessageQueue , Peek oderReceiveausführen können, müssen Sie die neue Instanz der-Klasse mit einer vorhandenen Warteschlange verknüpfen.Before you can call Send(Object), Peek, or Receive, you must associate the new instance of the MessageQueue class with an existing queue. An diesem Punkt können Sie die Warteschlangen Eigenschaften, z Category . b. und Label, bearbeiten.At that point, you can manipulate the queue properties such as Category and Label.

MessageQueueunterstützt zwei Arten von Nachrichten Abruf: synchron und asynchron.MessageQueue supports two types of message retrieval: synchronous and asynchronous. Die synchronen Methoden Peek , Receiveund bewirken, dass der Prozess Thread ein angegebenes Zeitintervall wartet, bis eine neue Nachricht in der Warteschlange eintrifft.The synchronous methods, Peek and Receive, cause the process thread to wait a specified time interval for a new message to arrive in the queue. Die asynchronen Methoden, BeginPeek und BeginReceiveermöglichen, dass die Haupt Anwendungsaufgaben in einem separaten Thread fortgesetzt werden, bis eine Nachricht in der Warteschlange eintrifft.The asynchronous methods, BeginPeek and BeginReceive, allow the main application tasks to continue in a separate thread until a message arrives in the queue. Diese Methoden funktionieren, indem Sie Rückruf Objekte und Zustands Objekte verwenden, um Informationen zwischen Threads zu übermitteln.These methods work by using callback objects and state objects to communicate information between threads.

Wenn Sie eine neue Instanz der MessageQueue -Klasse erstellen, erstellen Sie keine neue Message Queuing Warteschlange.When you create a new instance of the MessageQueue class, you are not creating a new Message Queuing queue. Stattdessen können Sie die Create(String)-, Delete(String)-und- Purge Methoden verwenden, um Warteschlangen auf dem Server zu verwalten.Instead, you can use the Create(String), Delete(String), and Purge methods to manage queues on the server.

Purge Andersalsstatic Delete(String) und sind Member, sodassMessageQueue Sie Sie ohne Erstellen einer neuen Instanz der-Klasse aufzurufen können. Create(String)Unlike Purge, Create(String) and Delete(String) are static members, so you can call them without creating a new instance of the MessageQueue class.

Sie können die- MessageQueue Eigenschaft des Path -Objekts mit einem von drei Namen festlegen: dem anzeigen Amen FormatName, dem oder Labeldem.You can set the MessageQueue object's Path property with one of three names: the friendly name, the FormatName, or the Label. Der Anzeige MachineName Name, der durch die-Eigenschaft und \ Private$ \ MachineName \ QueueName die-Eigenschaft der Warteschlange definiert wird, gilt QueueName für MachineName eine öffentliche Warteschlange .QueueName für eine private Warteschlange.The friendly name, which is defined by the queue's MachineName and QueueName properties, is MachineName\QueueName for a public queue, and MachineName\Private$\QueueName for a private queue. Die FormatName -Eigenschaft ermöglicht den Offline Zugriff auf Nachrichten Warteschlangen.The FormatName property allows offline access to message queues. Schließlich können Sie die- Label Eigenschaft der Warteschlange verwenden, um die PathWarteschlange festzulegen.Lastly, you can use the queue's Label property to set the queue's Path.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von MessageQueuefinden Sie im MessageQueue -Konstruktor.For a list of initial property values for an instance of MessageQueue, see the MessageQueue constructor.

Konstruktoren

MessageQueue() MessageQueue() MessageQueue() MessageQueue()

Initialisiert eine neue Instanz der MessageQueue-Klasse.Initializes a new instance of the MessageQueue class. 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.After the parameterless constructor initializes the new instance, you must set the instance's Path property before you can use the instance.

MessageQueue(String) MessageQueue(String) MessageQueue(String) MessageQueue(String)

Initialisiert eine neue Instanz der MessageQueue-Klasse, die auf die Message Queuing-Warteschlange am angegebenen Pfad verweist.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path.

MessageQueue(String, Boolean) MessageQueue(String, Boolean) MessageQueue(String, Boolean) 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.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path and with the specified read-access restriction.

MessageQueue(String, Boolean, Boolean) MessageQueue(String, Boolean, Boolean) MessageQueue(String, Boolean, Boolean) MessageQueue(String, Boolean, Boolean)

Initialisiert eine neue Instanz der MessageQueue-Klasse.Initializes a new instance of the MessageQueue class.

MessageQueue(String, Boolean, Boolean, QueueAccessMode) MessageQueue(String, Boolean, Boolean, QueueAccessMode) MessageQueue(String, Boolean, Boolean, QueueAccessMode) MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Initialisiert eine neue Instanz der MessageQueue-Klasse.Initializes a new instance of the MessageQueue class.

MessageQueue(String, QueueAccessMode) MessageQueue(String, QueueAccessMode) MessageQueue(String, QueueAccessMode) MessageQueue(String, QueueAccessMode)

Initialisiert eine neue Instanz der MessageQueue-Klasse.Initializes a new instance of the MessageQueue class.

Felder

InfiniteQueueSize InfiniteQueueSize InfiniteQueueSize InfiniteQueueSize

Legt fest, dass für eine Warteschlange keine Größenbeschränkung besteht.Specifies that no size restriction exists for a queue.

InfiniteTimeout InfiniteTimeout InfiniteTimeout InfiniteTimeout

Gibt an, dass für Methoden, die Meldungen einsehen oder empfangen, kein Timeout festgelegt ist.Specifies that no time-out exists for methods that peek or receive messages.

Eigenschaften

AccessMode AccessMode AccessMode AccessMode

Ruft einen Wert ab, der den Zugriffsmodus für die Warteschlange angibt.Gets a value that indicates the access mode for the queue.

Authenticate Authenticate Authenticate Authenticate

Ruft einen Wert ab, der angibt, ob die Warteschlange nur authentifizierte Meldungen akzeptiert, oder legt diesen fest.Gets or sets a value that indicates whether the queue accepts only authenticated messages.

BasePriority BasePriority BasePriority 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.Gets or sets the base priority Message Queuing uses to route a public queue's messages over the network.

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

Ruft einen Wert ab, der angibt, ob die Komponente ein Ereignis auslösen kann.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
CanRead CanRead CanRead CanRead

Ruft einen Wert ab, der angibt, ob die MessageQueue gelesen werden kann.Gets a value that indicates whether the MessageQueue can be read.

CanWrite CanWrite CanWrite CanWrite

Ruft einen Wert ab, der angibt, ob in die MessageQueue geschrieben werden kann.Gets a value that indicates whether the MessageQueue can be written to.

Category Category Category Category

Ruft die Kategorie der Warteschlange ab oder legt diese fest.Gets or sets the queue category.

Container Container Container Container

Ruft den IContainer ab, der die Component enthält.Gets the IContainer that contains the Component.

(Inherited from Component)
CreateTime CreateTime CreateTime CreateTime

Ruft Zeit und Datum der Erstellung der Warteschlange in Message Queuing ab.Gets the time and date that the queue was created in Message Queuing.

DefaultPropertiesToSend DefaultPropertiesToSend DefaultPropertiesToSend DefaultPropertiesToSend

Ruft die Eigenschaftswerte für Meldungen ab, die beim Senden einer Meldung an die Warteschlange standardmäßig verwendet werden.Gets or sets the message property values to be used by default when the application sends messages to the queue.

DenySharedReceive DenySharedReceive DenySharedReceive 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.Gets or sets a value that indicates whether this MessageQueue has exclusive access to receive messages from the Message Queuing queue.

DesignMode DesignMode DesignMode DesignMode

Ruft einen Wert ab, der angibt, ob sich Component gegenwärtig im Entwurfsmodus befindet.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
EnableConnectionCache EnableConnectionCache EnableConnectionCache EnableConnectionCache

Ruft einen Wert ab, der angibt, ob die Anwendung einen Verbindungscache verwaltet, oder legt diesen fest.Gets or sets a value that indicates whether a cache of connections will be maintained by the application.

EncryptionRequired EncryptionRequired EncryptionRequired EncryptionRequired

Ruft einen Wert ab, der angibt, ob die Warteschlange lediglich nicht private (nicht verschlüsselte) Meldungen akzeptiert, oder legt diesen fest.Gets or sets a value that indicates whether the queue accepts only non-private (non-encrypted) messages.

Events Events Events Events

Ruft die Liste der Ereignishandler ab, die dieser Component angefügt sind.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
FormatName FormatName FormatName FormatName

Ruft den eindeutigen Namen der Warteschlange ab, den Message Queuing beim Erstellen der Warteschlange erzeugt hat.Gets the unique queue name that Message Queuing generated at the time of the queue's creation.

Formatter Formatter Formatter 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.Gets or sets the formatter used to serialize an object into or deserialize an object from the body of a message read from or written to the queue.

Id Id Id Id

Ruft den eindeutigen Message Queuing-Bezeichner für die Warteschlange ab.Gets the unique Message Queuing identifier of the queue.

Label Label Label Label

Ruft die Beschreibung der Warteschlange ab oder legt diese fest.Gets or sets the queue description.

LastModifyTime LastModifyTime LastModifyTime LastModifyTime

Ruft den Zeitpunkt ab, zu dem die Eigenschaften einer Warteschlange zuletzt geändert wurden.Gets the last time the properties of a queue were modified.

MachineName MachineName MachineName MachineName

Ruft den Namen des Computers ab, auf dem sich die Message Queuing-Warteschlange befindet, oder legt diesen fest.Gets or sets the name of the computer where the Message Queuing queue is located.

MaximumJournalSize MaximumJournalSize MaximumJournalSize MaximumJournalSize

Ruft die maximale Größe der Journalwarteschlange ab oder legt diese fest.Gets or sets the maximum size of the journal queue.

MaximumQueueSize MaximumQueueSize MaximumQueueSize MaximumQueueSize

Ruft die maximale Größe der Warteschlange ab oder legt diese fest.Gets or sets the maximum size of the queue.

MessageReadPropertyFilter MessageReadPropertyFilter MessageReadPropertyFilter MessageReadPropertyFilter

Ruft den Eigenschaftenfilter für das Empfangen oder Einsehen von Meldungen ab oder legt diesen fest.Gets or sets the property filter for receiving or peeking messages.

MulticastAddress MulticastAddress MulticastAddress MulticastAddress

Eingeführt in MSMQ 3.0.Introduced in MSMQ 3.0. Ruft die der Warteschlange zugeordnete Multicastadresse ab oder oder legt diese fest.Gets or sets the multicast address associated with the queue.

Path Path Path Path

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.

QueueName QueueName QueueName QueueName

Ruft den angezeigten Namen für die Warteschlange ab oder legt diesen fest.Gets or sets the friendly name that identifies the queue.

ReadHandle ReadHandle ReadHandle ReadHandle

Ruft das systemeigene Handle zum Empfangen von Meldungen aus der Meldungswarteschlange ab.Gets the native handle used to read messages from the message queue.

Site Site Site Site

Ruft den ISite von Component ab oder legt ihn fest.Gets or sets the ISite of the Component.

(Inherited from Component)
SynchronizingObject SynchronizingObject SynchronizingObject SynchronizingObject

Ruft das Objekt ab, das den durch ein ReceiveCompleted-Ereignis oder ein PeekCompleted-Ereignis ausgelösten Ereignishandleraufruf marshallt, oder legt diesen fest.Gets or sets the object that marshals the event-handler call resulting from a ReceiveCompleted or PeekCompleted event.

Transactional Transactional Transactional Transactional

Ruft einen Wert ab, der angibt, ob die Warteschlange nur Transaktionen akzeptiert.Gets a value that indicates whether the queue accepts only transactions.

UseJournalQueue UseJournalQueue UseJournalQueue UseJournalQueue

Ruft einen Wert ab, der angibt, ob abgerufene Meldungen in die Journalwarteschlange kopiert werden, oder legt diesen fest.Gets or sets a value that indicates whether received messages are copied to the journal queue.

WriteHandle WriteHandle WriteHandle WriteHandle

Das systemeigene Handle zum Senden von Meldungen an die Meldungswarteschlange.Gets the native handle used to send messages to the message queue.

Methoden

BeginPeek() BeginPeek() BeginPeek() BeginPeek()

Initiiert einen asynchronen Lesevorgang ohne Timeout. Die Operation wird erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist.Initiates an asynchronous peek operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginPeek(TimeSpan) BeginPeek(TimeSpan) BeginPeek(TimeSpan) BeginPeek(TimeSpan)

Initiiert einen asynchronen Lesevorgang mit einem festgelegten Timeout. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.Initiates an asynchronous peek operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback) BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback) BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback) 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.Initiates an asynchronous peek operation that has a specified time-out and that uses a specified cursor, a specified peek action, and a specified state object. Das Zustandsobjekt stellt für die Lebensdauer des Vorgangs zugeordnete Informationen bereit.The state object provides associated information throughout the lifetime of the operation. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt.This overload receives notification, through a callback, of the identity of the event handler for the operation. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Object) BeginPeek(TimeSpan, Object) BeginPeek(TimeSpan, Object) 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.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Object, AsyncCallback) BeginPeek(TimeSpan, Object, AsyncCallback) BeginPeek(TimeSpan, Object, AsyncCallback) 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.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt.This overload receives notification, through a callback, of the identity of the event handler for the operation. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive() BeginReceive() BeginReceive() BeginReceive()

Initiiert eine asynchrone Receive-Methode ohne Timeout. Die Operation wird erst abgeschlossen, wenn eine Meldung in der Warteschlange verfügbar ist.Initiates an asynchronous receive operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginReceive(TimeSpan) BeginReceive(TimeSpan) BeginReceive(TimeSpan) BeginReceive(TimeSpan)

Initiiert eine asynchrone Receive-Methode mit einem festgelegten Timeout. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.Initiates an asynchronous receive operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback) BeginReceive(TimeSpan, Cursor, Object, AsyncCallback) BeginReceive(TimeSpan, Cursor, Object, AsyncCallback) 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.Initiates an asynchronous receive operation that has a specified time-out and uses a specified cursor and a specified state object. Das Zustandsobjekt stellt für die Lebensdauer des Vorgangs zugeordnete Informationen bereit.The state object provides associated information throughout the lifetime of the operation. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt.This overload receives notification, through a callback, of the identity of the event handler for the operation. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object) BeginReceive(TimeSpan, Object) BeginReceive(TimeSpan, Object) 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.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object, AsyncCallback) BeginReceive(TimeSpan, Object, AsyncCallback) BeginReceive(TimeSpan, Object, AsyncCallback) 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.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Dieser Überladung wird in einem Rückruf die Identität des Ereignishandlers für den Vorgang mitgeteilt.This overload receives notification, through a callback, of the identity of the event handler for the operation. Der Vorgang ist abgeschlossen, wenn entweder eine Meldung in der Warteschlange verfügbar wird oder der Timeout auftritt.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

ClearConnectionCache() ClearConnectionCache() ClearConnectionCache() ClearConnectionCache()

Löscht den Verbindungscache.Clears the connection cache.

Close() Close() Close() Close()

Gibt alle von der MessageQueue reservierten Ressourcen frei.Frees all resources allocated by the MessageQueue.

Create(String) Create(String) Create(String) Create(String)

Erstellt eine nicht transaktionale Message Queuing-Warteschlange unter dem angegebenen Pfad.Creates a non-transactional Message Queuing queue at the specified path.

Create(String, Boolean) Create(String, Boolean) Create(String, Boolean) Create(String, Boolean)

Erstellt eine transaktionale oder eine nicht transaktionale Message Queuing-Warteschlange unter dem angegebenen Pfad.Creates a transactional or non-transactional Message Queuing queue at the specified path.

CreateCursor() CreateCursor() CreateCursor() CreateCursor()

Erstellt einen neuen Cursor für die aktuelle Meldungswarteschlange.Creates a new Cursor for the current message queue.

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Delete(String) Delete(String) Delete(String) Delete(String)

Löschte eine Warteschlange auf einem Message Queuing-Server.Deletes a queue on a Message Queuing server.

Dispose() Dispose() Dispose() Dispose()

Gibt alle vom Component verwendeten Ressourcen frei.Releases all resources used by the Component.

(Inherited from Component)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Gibt die von der MessageQueue-Klasse verwendeten Ressourcen (mit Ausnahme des Speichers) frei.Disposes of the resources (other than memory) used by the MessageQueue.

EndPeek(IAsyncResult) EndPeek(IAsyncResult) EndPeek(IAsyncResult) EndPeek(IAsyncResult)

Schließt den angegebenen asynchronen Lesevorgang ab.Completes the specified asynchronous peek operation.

EndReceive(IAsyncResult) EndReceive(IAsyncResult) EndReceive(IAsyncResult) EndReceive(IAsyncResult)

Schließt die angegebene asynchrone Receive-Methode ab.Completes the specified asynchronous receive operation.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Exists(String) Exists(String) Exists(String) Exists(String)

Bestimmt, ob unter dem angegeben Pfad eine Message Queuing-Warteschlange vorhanden ist.Determines whether a Message Queuing queue exists at the specified path.

GetAllMessages() GetAllMessages() GetAllMessages() GetAllMessages()

Gibt alle Meldungen in der Warteschlange zurück.Returns all the messages that are in the queue.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Listet die Meldungen in einer Warteschlange auf.Enumerates the messages in a queue. GetEnumerator() ist veraltet.GetEnumerator() is deprecated. GetMessageEnumerator2() sollte stattdessen verwendet werden.GetMessageEnumerator2() should be used instead.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetMachineId(String) GetMachineId(String) GetMachineId(String) GetMachineId(String)

Ruft den Computerbezeichner ab, auf dem sich die Warteschlange befindet, auf die diese MessageQueue verweist.Gets the identifier of the computer on which the queue referenced by this MessageQueue is located.

GetMessageEnumerator() GetMessageEnumerator() GetMessageEnumerator() GetMessageEnumerator()

Erstellt ein Enumerationsobjekt für alle Meldungen in der Warteschlange.Creates an enumerator object for all the messages in the queue. GetMessageEnumerator() ist veraltet.GetMessageEnumerator() is deprecated. GetMessageEnumerator2() sollte stattdessen verwendet werden.GetMessageEnumerator2() should be used instead.

GetMessageEnumerator2() GetMessageEnumerator2() GetMessageEnumerator2() GetMessageEnumerator2()

Erstellt ein Enumerationsobjekt für alle Meldungen in der Warteschlange.Creates an enumerator object for all the messages in the queue.

GetMessageQueueEnumerator() GetMessageQueueEnumerator() GetMessageQueueEnumerator() GetMessageQueueEnumerator()

Stellt eine Vorwärts-Cursorsemantik zum Durchlaufen aller öffentlichen Warteschlangen im Netzwerk bereit.Provides forward-only cursor semantics to enumerate through all public queues on the network.

GetMessageQueueEnumerator(MessageQueueCriteria) GetMessageQueueEnumerator(MessageQueueCriteria) GetMessageQueueEnumerator(MessageQueueCriteria) GetMessageQueueEnumerator(MessageQueueCriteria)

Stellt eine Vorwärts-Cursorsemantik zum Durchlaufen aller öffentlichen Warteschlangen im Netzwerk bereit, die die angegebenen Kriterien erfüllen.Provides forward-only cursor semantics to enumerate through all public queues on the network that meet the specified criteria.

GetPrivateQueuesByMachine(String) GetPrivateQueuesByMachine(String) GetPrivateQueuesByMachine(String) GetPrivateQueuesByMachine(String)

Ruft alle privaten Warteschlangen auf dem angegebenen Computer ab.Retrieves all the private queues on the specified computer.

GetPublicQueues() GetPublicQueues() GetPublicQueues() GetPublicQueues()

Ruft alle öffentlichen Warteschlangen im Netzwerk ab.Retrieves all the public queues on the network.

GetPublicQueues(MessageQueueCriteria) GetPublicQueues(MessageQueueCriteria) GetPublicQueues(MessageQueueCriteria) GetPublicQueues(MessageQueueCriteria)

Ruft alle öffentlichen Warteschlangen im Netzwerk ab, die die angegebenen Kriterien erfüllen.Retrieves all the public queues on the network that meet the specified criteria.

GetPublicQueuesByCategory(Guid) GetPublicQueuesByCategory(Guid) GetPublicQueuesByCategory(Guid) GetPublicQueuesByCategory(Guid)

Ruft alle öffentlichen Warteschlangen im Netzwerk ab, die der angegebenen Kategorie angehören.Retrieves all the public queues on the network that belong to the specified category.

GetPublicQueuesByLabel(String) GetPublicQueuesByLabel(String) GetPublicQueuesByLabel(String) GetPublicQueuesByLabel(String)

Ruft alle öffentlichen Warteschlangen im Netzwerk ab, die die angegebene Bezeichnung aufweisen.Retrieves all the public queues on the network that carry the specified label.

GetPublicQueuesByMachine(String) GetPublicQueuesByMachine(String) GetPublicQueuesByMachine(String) GetPublicQueuesByMachine(String)

Ruft alle öffentlichen Warteschlangen auf dem angegebenen Computer ab.Retrieves all the public queues that reside on the specified computer.

GetSecurityContext() GetSecurityContext() GetSecurityContext() GetSecurityContext()

Ruft den Sicherheitskontext ab, den MSMQ zum Zeitpunkt des Aufrufs dem aktuellen Benutzer zuordnet (Threadidentität).Retrieves the security context that MSMQ associates with the current user (thread identity) at the time of this call.

GetService(Type) GetService(Type) GetService(Type) GetService(Type)

Gibt ein Objekt zurück, das einen von der Component oder von deren Container bereitgestellten Dienst darstellt.Returns an object that represents a service provided by the Component or by its Container.

(Inherited from Component)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
Peek() Peek() Peek() Peek()

Wird beendet, ohne die erste Meldung in der Warteschlange zu entfernen (einzusehen), auf die diese MessageQueue verweist.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread bis zum Eingang einer Meldung.The Peek() method is synchronous, so it blocks the current thread until a message becomes available.

Peek(TimeSpan) Peek(TimeSpan) Peek(TimeSpan) Peek(TimeSpan)

Wird beendet, ohne die erste Meldung in der Warteschlange zu entfernen (einzusehen), auf die diese MessageQueue verweist.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread, bis eine Meldung verfügbar wird oder der Timeout eintritt.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

Peek(TimeSpan, Cursor, PeekAction) Peek(TimeSpan, Cursor, PeekAction) Peek(TimeSpan, Cursor, PeekAction) Peek(TimeSpan, Cursor, PeekAction)

Wird beendet, ohne die aktuelle oder die nächste Meldung mithilfe des angegebenen Cursors zu entfernen (einzusehen).Returns without removing (peeks) the current or next message in the queue, using the specified cursor. Die Peek()-Methode ist synchron. Sie blockiert daher den aktuellen Thread, bis eine Meldung verfügbar wird oder der Timeout eintritt.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

PeekByCorrelationId(String) PeekByCorrelationId(String) PeekByCorrelationId(String) 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.Peeks the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

PeekByCorrelationId(String, TimeSpan) PeekByCorrelationId(String, TimeSpan) PeekByCorrelationId(String, TimeSpan) 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.Peeks the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

PeekById(String) PeekById(String) PeekById(String) PeekById(String)

Sieht die Meldung ein, deren Meldungs-ID mit dem id-Parameter übereinstimmt.Peeks the message whose message identifier matches the id parameter.

PeekById(String, TimeSpan) PeekById(String, TimeSpan) PeekById(String, TimeSpan) PeekById(String, TimeSpan)

Sieht die Meldung ein, deren Meldungs-ID mit dem id-Parameter übereinstimmt.Peeks the message whose message identifier matches the id parameter. Wartet, bis die Meldung in der Warteschlange eingeht oder ein Timeout auftritt.Waits until the message appears in the queue or a time-out occurs.

PeekByLookupId(Int64) PeekByLookupId(Int64) PeekByLookupId(Int64) PeekByLookupId(Int64)

Eingeführt in MSMQ 3.0.Introduced in MSMQ 3.0. Sieht die Meldung ein, die dem angegebenen Suchbezeichner in einer nicht transaktionalen Warteschlange entspricht.Peeks at the message that matches the given lookup identifier from a non-transactional queue.

PeekByLookupId(MessageLookupAction, Int64) PeekByLookupId(MessageLookupAction, Int64) PeekByLookupId(MessageLookupAction, Int64) PeekByLookupId(MessageLookupAction, Int64)

Eingeführt in MSMQ 3.0.Introduced in MSMQ 3.0. Sieht eine bestimmte Meldung in der Warteschlange ein.Peeks at a specific message from the queue. Die Meldung kann anhand eines Suchbezeichners oder anhand der Position am Anfang oder am Ende der Warteschlange angegeben werden.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Purge() Purge() Purge() Purge()

Löscht alle in der Warteschlange enthaltenen Meldungen.Deletes all the messages contained in the queue.

Receive() Receive() Receive() Receive()

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the queue referenced by the MessageQueue. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction)

Empfängt die erste verfügbare Meldung aus der transaktionalen Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the transactional queue referenced by the MessageQueue. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the queue referenced by the MessageQueue. Dieser Aufruf ist synchron und blockiert den aktuellen Ausführungsthread, bis eine Meldung verfügbar ist.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan) 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.Receives the first message available in the queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange.Receives the current message in the queue, using a specified cursor. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange.Receives the current message in the queue, using a specified cursor. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Empfängt unter Verwendung des aktuellen Cursors die aktuelle Meldung in der Warteschlange.Receives the current message in the queue, using a specified cursor. Wenn keine Meldung verfügbar ist, wartet diese Methode, bis eine Meldung verfügbar ist oder der Timeout abläuft.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) 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.Receives the first message available in the transactional queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType)

Empfängt die erste verfügbare Meldung aus der Warteschlange, auf die die MessageQueue verweist.Receives the first message available in the queue referenced by the MessageQueue. Dieser Aufruf ist synchron und wartet, bis entweder eine Meldung in der Warteschlange verfügbar ist oder der Timeout abläuft.This call is synchronous, and waits until either a message is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String) ReceiveByCorrelationId(String) ReceiveByCorrelationId(String) 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.Receives the message that matches the given correlation identifier (from a non-transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, MessageQueueTransaction) ReceiveByCorrelationId(String, MessageQueueTransaction) ReceiveByCorrelationId(String, MessageQueueTransaction) 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.Receives the message that matches the given correlation identifier (from a transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, MessageQueueTransactionType) ReceiveByCorrelationId(String, MessageQueueTransactionType) ReceiveByCorrelationId(String, MessageQueueTransactionType) 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.Receives the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, TimeSpan) ReceiveByCorrelationId(String, TimeSpan) ReceiveByCorrelationId(String, TimeSpan) 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.Receives the message that matches the given correlation identifier (from a non-transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction) 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.Receives the message that matches the given correlation identifier (from a transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType) 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.Receives the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveById(String) ReceiveById(String) ReceiveById(String) 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.Receives the message that matches the given identifier from a non-transactional queue and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, MessageQueueTransaction) ReceiveById(String, MessageQueueTransaction) ReceiveById(String, MessageQueueTransaction) 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.Receives the message that matches the given identifier (from a transactional queue) and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, MessageQueueTransactionType) ReceiveById(String, MessageQueueTransactionType) ReceiveById(String, MessageQueueTransactionType) 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.Receives the message that matches the given identifier and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, TimeSpan) ReceiveById(String, TimeSpan) ReceiveById(String, TimeSpan) 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.Receives the message that matches the given identifier (from a non-transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveById(String, TimeSpan, MessageQueueTransaction) ReceiveById(String, TimeSpan, MessageQueueTransaction) ReceiveById(String, TimeSpan, MessageQueueTransaction) 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.Receives the message that matches the given identifier (from a transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveById(String, TimeSpan, MessageQueueTransactionType) ReceiveById(String, TimeSpan, MessageQueueTransactionType) ReceiveById(String, TimeSpan, MessageQueueTransactionType) 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.Receives the message that matches the given identifier and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveByLookupId(Int64) ReceiveByLookupId(Int64) ReceiveByLookupId(Int64) ReceiveByLookupId(Int64)

Eingeführt in MSMQ 3.0.Introduced in MSMQ 3.0. Empfängt die Meldung, die dem angegebenen Suchbezeichner in einer nicht transaktionalen Warteschlange entspricht.Receives the message that matches the given lookup identifier from a non-transactional queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)

Eingeführt in MSMQ 3.0.Introduced in MSMQ 3.0. Empfängt eine bestimmte Meldung aus einer transaktionalen Warteschlange.Receives a specific message from a transactional queue. Die Meldung kann anhand eines Suchbezeichners oder anhand der Position am Anfang oder am Ende der Warteschlange angegeben werden.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)

Eingeführt in MSMQ 3.0.Introduced in MSMQ 3.0. Empfängt unter Verwendung des angegebenen Transaktionskontexts eine bestimmte Meldung aus der Warteschlange.Receives a specific message from the queue, using the specified transaction context. Die Meldung kann anhand eines Suchbezeichners oder anhand der Position am Anfang oder am Ende der Warteschlange angegeben werden.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Refresh() Refresh() Refresh() Refresh()

Aktualisiert die von der MessageQueue dargestellten Eigenschaften, sodass sie den aktuellen Zustand der Ressource wiedergeben.Refreshes the properties presented by the MessageQueue to reflect the current state of the resource.

ResetPermissions() ResetPermissions() ResetPermissions() ResetPermissions()

Setzt die Berechtigungsliste auf die Standardwerte des Betriebssystems zurück.Resets the permission list to the operating system's default values. Entfernt sämtliche Berechtigungen für Warteschlangen, die an die Standardliste angefügt wurden.Removes any queue permissions you have appended to the default list.

Send(Object) Send(Object) Send(Object) Send(Object)

Sendet ein Objekt an die nicht transaktionale Warteschlange, auf die diese MessageQueue verweist.Sends an object to non-transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransaction) Send(Object, MessageQueueTransaction) Send(Object, MessageQueueTransaction) Send(Object, MessageQueueTransaction)

Sendet ein Objekt an die transaktionale Warteschlange, auf die diese MessageQueue verweist.Sends an object to the transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransactionType) Send(Object, MessageQueueTransactionType) Send(Object, MessageQueueTransactionType) Send(Object, MessageQueueTransactionType)

Sendet ein Objekt an die Warteschlange, auf die diese MessageQueue verweist.Sends an object to the queue referenced by this MessageQueue.

Send(Object, String) Send(Object, String) Send(Object, String) 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.Sends an object to the non-transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransaction) Send(Object, String, MessageQueueTransaction) Send(Object, String, MessageQueueTransaction) 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.Sends an object to the transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransactionType) Send(Object, String, MessageQueueTransactionType) Send(Object, String, MessageQueueTransactionType) Send(Object, String, MessageQueueTransactionType)

Sendet ein Objekt an die Warteschlange, auf die diese MessageQueue verweist, und gibt eine Bezeichnung für die Meldung an.Sends an object to the queue referenced by this MessageQueue and specifies a label for the message.

SetPermissions(AccessControlList) SetPermissions(AccessControlList) SetPermissions(AccessControlList) SetPermissions(AccessControlList)

Weist der Warteschlange anhand einer Zugriffssteuerungsliste Zugriffsrechte zu.Assigns access rights to the queue based on the contents of an access control list.

SetPermissions(MessageQueueAccessControlEntry) SetPermissions(MessageQueueAccessControlEntry) SetPermissions(MessageQueueAccessControlEntry) SetPermissions(MessageQueueAccessControlEntry)

Weist der Warteschlange anhand eines Zugriffssteuerungseintrags Zugriffsrechte zu.Assigns access rights to the queue based on the contents of an access control entry.

SetPermissions(String, MessageQueueAccessRights) SetPermissions(String, MessageQueueAccessRights) SetPermissions(String, MessageQueueAccessRights) SetPermissions(String, MessageQueueAccessRights)

Gewährt einem Computer, einer Gruppe oder einem Benutzer die angegebenen Zugriffsrechte.Gives a computer, group, or user the specified access rights.

SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType) SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType) SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType) 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).Gives a computer, group, or user the specified access rights, with the specified access control type (allow, deny, revoke, or set).

ToString() ToString() ToString() ToString()

Gibt einen String zurück, der den Namen der Component enthält (sofern vorhanden).Returns a String containing the name of the Component, if any. Diese Methode darf nicht überschrieben werden.This method should not be overridden.

(Inherited from Component)

Ereignisse

Disposed Disposed Disposed Disposed

Tritt ein, wenn die Komponente durch einen Aufruf der Dispose()-Methode freigegeben wird.Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)
PeekCompleted PeekCompleted PeekCompleted PeekCompleted

Tritt ein, wenn eine Meldung gelesen wird, ohne sie aus der Warteschlange zu entfernen.Occurs when a message is read without being removed from the queue. Dies ist ein Ergebnis eines asynchronen BeginPeek()-Vorgangs.This is a result of the asynchronous operation, BeginPeek().

ReceiveCompleted ReceiveCompleted ReceiveCompleted ReceiveCompleted

Tritt ein, wenn eine Meldung aus der Warteschlange entfernt wurde.Occurs when a message has been removed from the queue. Dieses Ereignis wird von dem asynchronen BeginReceive()-Vorgang ausgelöst.This event is raised by the asynchronous operation, BeginReceive().

Erweiterungsmethoden

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Wandelt die Elemente eines IEnumerable in den angegebenen Typ umCasts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtert die Elemente eines IEnumerable anhand eines angegebenen TypsFilters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.Converts an IEnumerable to an IQueryable.

Gilt für:

Threadsicherheit

Nur die GetAllMessages() -Methode ist Thread sicher.Only the GetAllMessages() method is thread safe.

Siehe auch