MessageQueue-Klasse
Ermöglicht den Zugriff auf eine Warteschlange auf einem Message Queuing-Server.
Namespace: System.Messaging
Assembly: System.Messaging (in system.messaging.dll)
Syntax
'Declaration
Public Class MessageQueue
Inherits Component
Implements IEnumerable
'Usage
Dim instance As MessageQueue
public class MessageQueue : Component, IEnumerable
public ref class MessageQueue : public Component, IEnumerable
public class MessageQueue extends Component implements IEnumerable
public class MessageQueue extends Component implements IEnumerable
Hinweise
Mithilfe der Message Queuing-Technologie können Anwendungen, die zu verschiedenen Zeiten ausgeführt werden, über heterogene Netzwerke und Systeme kommunizieren, die zeitweise offline sein können. Anwendungen können Meldungen an Warteschlangen senden und aus Warteschlangen empfangen oder einsehen (Lesen ohne Entfernen). Message Queuing ist eine optionale Komponente von Windows 2000 und Windows NT, die zusätzlich installiert werden muss.
Die MessageQueue-Klasse ist ein Wrapper für Message Queuing. Da es zahlreiche Message Queuing-Versionen gibt, kann das Verhalten bei Verwendung der MessageQueue-Klasse unter verschiedenen Betriebssystemen geringfügig variieren. Informationen über bestimmte Features der verschiedenen Versionen von Message Queuing finden Sie in MSDN unter dem Thema "Platform SDK" im Abschnitt "What's New in Message Queuing" (nur auf Englisch verfügbar).
Die MessageQueue-Klasse stellt einen Verweis auf eine Message Queuing-Warteschlange bereit. Sie können im MessageQueue-Konstruktor einen Pfad angeben, um eine Verbindung mit einer vorhandenen Ressource herzustellen, oder Sie können auf dem Server eine neue Warteschlange erstellen. Bevor Sie Send(Object), Peek oder Receive aufrufen können, müssen Sie die neue Instanz der MessageQueue-Klasse einer vorhandenen Warteschlange zuordnen. Danach können Sie auf Eigenschaften der Warteschlange wie Category oder Label zugreifen.
MessageQueue unterstützt zwei Formen des Meldungsabrufs: synchron und asynchron. Die synchronen Methoden Peek und Receive bewirken, dass der Prozessthread bis zum Ablauf einer festgelegten Zeitspanne auf das Eingehen einer neuen Meldung in der Warteschlange wartet. Bei den asynchronen Methoden BeginPeek und BeginReceive kann die Ausführung der Hauptanwendungstasks in einem eigenen Thread fortgesetzt werden, bis eine Meldung in die Warteschlange eingeht. Diese Methoden verwenden Rückruf- und Zustandsobjekte zur Übermittlung von Informationen zwischen Threads.
Beim Erstellen einer neuen Instanz der MessageQueue-Klasse wird keine neue Message Queuing-Warteschlange erstellt. Sie können die Warteschlangen jedoch mithilfe der Create(String)-Methode, der Delete-Methode und der Purge-Methode auf dem Server verwalten.
Im Gegensatz zu Purge sind Create(String) und Delete static Member und können daher ohne vorherige Erstellung einer neuen Instanz der MessageQueue-Klasse aufgerufen werden.
Sie können die Path-Eigenschaft des MessageQueue-Objekts auf einen der drei folgenden Namen festlegen: den angezeigten Namen, denFormatName oder das Label. Der angezeigte Name, der durch die MachineName-Eigenschaft und die QueueName-Eigenschaft der Warteschlange festgelegt ist, lautet MachineName\QueueName bei einer öffentlichen Warteschlange und MachineName\Private$\QueueName bei einer privaten Warteschlange. Die FormatName-Eigenschaft ermöglicht den Offlinezugriff auf Warteschlangen. Darüber hinaus kann mithilfe der Label-Eigenschaft der Warteschlange der Path der Wartschlange festgelegt werden.
Eine Liste der anfänglichen Eigenschaftenwerte für eine Instanz von MessageQueue finden Sie unter MessageQueue-Konstruktor.
Beispiel
Im folgenden Codebeispiel werden neue MessageQueue-Objekte erstellt, wobei Pfadnamen in unterschiedlicher Syntax angegeben werden. In allen Fällen wird eine Meldung an die Warteschlange gesendet, deren Pfad im Konstruktor angegeben wurde.
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
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.
}
}
}
}
#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;
}
package MyProject;
import System.*;
import System.Messaging.*;
/// <summary>
/// Provides a container class for the example.
/// </summary>
public class MyNewQueue
{
//**************************************************
// Provides an entry point into the application.
//
// This example demonstrates several ways to set
// a queue's path.
//**************************************************
public static void main(String[] args)
{
// Create a new instance of the class.
MyNewQueue myNewQueue = new MyNewQueue();
myNewQueue.SendPublic();
myNewQueue.SendPrivate();
myNewQueue.SendByLabel();
myNewQueue.SendByFormatName();
myNewQueue.MonitorComputerJournal();
myNewQueue.MonitorQueueJournal();
myNewQueue.MonitorDeadLetter();
myNewQueue.MonitorTransactionalDeadLetter();
return;
} //main
// References public queues.
public void SendPublic()
{
MessageQueue myQueue = new MessageQueue(".\\myQueue");
myQueue.Send("Public queue by path name.");
return;
} //SendPublic
// References private queues.
public void SendPrivate()
{
MessageQueue myQueue = new MessageQueue(".\\Private$\\myQueue");
myQueue.Send("Private queue by path name.");
return;
} //SendPrivate
// References queues by label.
public void SendByLabel()
{
MessageQueue myQueue = new MessageQueue("Label:TheLabel");
myQueue.Send("Queue by label.");
return;
} //SendByLabel
// References queues by format name.
public void SendByFormatName()
{
MessageQueue myQueue =
new MessageQueue("FormatName:Public=5A5F7535-AE9A-41d4"
+ "-935C-845C2AFF7112");
myQueue.Send("Queue by format name.");
return;
} //SendByFormatName
// References computer journal queues.
public void MonitorComputerJournal()
{
MessageQueue computerJournal = new MessageQueue(".\\Journal$");
while (true) {
Message journalMessage = computerJournal.Receive();
// Process the journal message.
}
} //MonitorComputerJournal
// References queue journal queues.
public void MonitorQueueJournal()
{
MessageQueue queueJournal = new MessageQueue(".\\myQueue\\Journal$");
while (true) {
Message journalMessage = queueJournal.Receive();
// Process the journal message.
}
} //MonitorQueueJournal
// References dead-letter queues.
public void MonitorDeadLetter()
{
MessageQueue deadLetter = new MessageQueue(".\\DeadLetter$");
while (true) {
Message deadMessage = deadLetter.Receive();
// Process the dead-letter message.
}
} //MonitorDeadLetter
// References transactional dead-letter queues.
public void MonitorTransactionalDeadLetter()
{
MessageQueue objTxDeadLetter = new MessageQueue(".\\XactDeadLetter$");
while (true) {
Message txDeadLetter = objTxDeadLetter.Receive();
// Process the transactional dead-letter message.
}
} //MonitorTransactionalDeadLetter
} //MyNewQueue
Im folgenden Codebeispiel wird eine Meldung an eine Warteschlange gesendet und mithilfe einer anwendungsspezifischen Klasse mit der Bezeichnung Order eine Meldung aus einer Warteschlange empfangen.
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
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;
}
}
}
#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;
}
package MyProject;
import System.*;
import System.Messaging.*;
// 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;
} //Order
/// <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(String[] args)
{
// 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;
} //main
//**************************************************
// 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.get_Now();
// Connect to a queue on the local computer.
MessageQueue myQueue = new MessageQueue(".\\myQueue");
// Send the Order to the queue.
myQueue.Send(sentOrder);
return;
} //SendMessage
//**************************************************
// 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.set_Formatter(new XmlMessageFormatter(new Type[]
{ MyProject.Order.class.ToType() }));
try {
// Receive and format the message.
Message myMessage = myQueue.Receive();
Order myOrder = (Order)(myMessage.get_Body());
// Display message information.
Console.WriteLine("Order ID: "+((Int32)myOrder.orderId).ToString());
Console.WriteLine("Sent: " + myOrder.orderTime.ToString());
}
catch (MessageQueueException exp) {
// Handle Message Queuing exceptions.
}
// Handle invalid serialization format.
catch (InvalidOperationException e) {
Console.WriteLine(e.get_Message());
}
// Catch other exceptions as necessary.
return;
} //ReceiveMessage
} //MyNewQueue
Vererbungshierarchie
System.Object
System.MarshalByRefObject
System.ComponentModel.Component
System.Messaging.MessageQueue
Threadsicherheit
Bei Multithreadoperationen sind nur die folgenden Operationen sicher: BeginPeek, BeginReceive, EndPeek, EndReceive, GetAllMessages, Peek und Receive.
Plattformen
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0
Siehe auch
Referenz
MessageQueue-Member
System.Messaging-Namespace
Message-Klasse
DefaultPropertiesToSend-Klasse
MessageQueueException
MessageQueue
Peek
Receive
BeginPeek
BeginReceive
Path
Label
FormatName
QueueName
MachineName