Message-Klasse
Stellt den Zugriff auf die Eigenschaften bereit, die zur Definition einer Message Queuing-Meldung erforderlich sind.
Namespace: System.Messaging
Assembly: System.Messaging (in system.messaging.dll)
Syntax
'Declaration
Public Class Message
Inherits Component
'Usage
Dim instance As Message
public class Message : Component
public ref class Message : public Component
public class Message extends Component
public class Message extends Component
Hinweise
Mithilfe der Message-Klasse können Sie die Meldungen in einer Warteschlange einsehen oder empfangen und darüber hinaus die Meldungseigenschaften beim Senden von Meldungen an eine Warteschlange genau steuern.
Die MessageQueue verwendet die Message-Klasse zum Einsehen und Abrufen von Meldungen aus einer Warteschlage, da sowohl die MessageQueue.Peek-Methode als auch die MessageQueue.Receive-Methode eine Instanz der Message erstellen und die Eigenschaften für die Instanz festlegen. Die schreibgeschützten Eigenschaften der Message-Klasse liefern Informationen für das Abrufen von Meldungen aus einer Warteschlange. Die Lese-/Schreibeigenschaften werden beim Senden und beim Abrufen von Meldungen verwendet. Wenn die MessageQueue eine Meldung aus einer Warteschlange einsieht oder empfängt, wird anhand ihrer MessageReadPropertyFilter-Eigenschaft bestimmt, welche Eigenschaften der Meldung abgerufen werden.
In der Send-Methode der MessageQueue-Klasse können Sie einen beliebigen Objekttyp für eine Meldung angeben, die an die Warteschlange gesendet werden soll. Die DefaultPropertiesToSend-Eigenschaft der MessageQueue-Instanz kann zur Angabe von Einstellungen für generische Meldungen an die Warteschlange verwendet werden. Es können Einstellungen für Formatierer, Bezeichnung, Verschlüsselung und Authentifizierung vorgenommen werden. Ebenso können Sie Werte für die entsprechenden DefaultPropertiesToSend-Member angeben, wenn Sie eine Messaginganwendung für das Behandeln von Bestätigungs- und Berichtsmeldungen einrichten. Wenn Sie eine Message-Instanz zum Senden einer Meldung an die Warteschlange verwenden, können Sie viele dieser Eigenschaften ändern, entweder für eine einzelne Meldung oder für nachfolgende Meldungen. Message-Eigenschaften haben Vorrang vor DefaultPropertiesToSend .
Meldungsdaten werden in der Body-Eigenschaft und teilweise in der AppSpecific-Eigenschaft und der Extension-Eigenschaft gespeichert. Wenn Meldungsdaten verschlüsselt, serialisiert oder deserialisiert werden, betrifft dies nur den Inhalt der Body-Eigenschaft.
Der Inhalt der Body-Eigenschaft wird beim Senden mit der von Ihnen angegebenen Formatter-Eigenschaft serialisiert. Der serialisierte Inhalt wird in der BodyStream-Eigenschaft abgelegt. Die BodyStream-Eigenschaft kann aber auch direkt festgelegt werden, um z. B. eine Datei als Meldungsinhalt zu senden. Die Body-Eigenschaft und die Formatter-Eigenschaft können vor dem Senden der Meldung jederzeit geändert werden. Die Daten werden beim Aufruf von Send korrekt serialisiert.
Die über die MessageQueue.DefaultPropertiesToSend-Eigenschaft definierten Eigenschaften betreffen nur Meldungen, die nicht vom Typ Message sind. Wenn Sie die DefaultPropertiesToSend-Eigenschaft für eine MessageQueue angeben, setzen die gleichnamigen Eigenschaften einer an die Warteschlange gesendeten Message-Instanz diese Standardeigenschaften außer Kraft.
Eine Liste der anfänglichen Eigenschaftenwerte für eine Instanz von Message finden Sie unter Message-Konstruktor.
Beispiel
Im folgenden Codebeispiel wird das Formatieren eines Meldungstextes mithilfe des BinaryMessageFormatter veranschaulicht.
Imports System
Imports System.Messaging
Imports System.Drawing
Imports System.IO
Namespace MyProj
_
Public Class MyNewQueue
'**************************************************
' Provides an entry point into the application.
'
' This example sends and receives a message from
' a queue.
'**************************************************
Public Shared Sub Main()
' Create a new instance of the class.
Dim myNewQueue As New MyNewQueue()
' Create a queue on the local computer.
CreateQueue(".\myQueue")
' Send a message to a queue.
myNewQueue.SendMessage()
' Receive a message from a queue.
myNewQueue.ReceiveMessage()
Return
End Sub 'Main
'**************************************************
' Creates a new queue.
'**************************************************
Public Shared Sub CreateQueue(queuePath As String)
Try
If Not MessageQueue.Exists(queuePath) Then
MessageQueue.Create(queuePath)
Else
Console.WriteLine((queuePath + " already exists."))
End If
Catch e As MessageQueueException
Console.WriteLine(e.Message)
End Try
End Sub 'CreateQueue
'**************************************************
' Sends an image to a queue, using the BinaryMessageFormatter.
'**************************************************
Public Sub SendMessage()
Try
' Create a new bitmap.
' The file must be in the \bin\debug or \bin\retail folder, or
' you must give a full path to its location.
Dim myImage As Image = Bitmap.FromFile("SentImage.bmp")
' Connect to a queue on the local computer.
Dim myQueue As New MessageQueue(".\myQueue")
Dim myMessage As New Message(myImage, New BinaryMessageFormatter())
' Send the image to the queue.
myQueue.Send(myMessage)
Catch e As ArgumentException
Console.WriteLine(e.Message)
End Try
Return
End Sub 'SendMessage
'**************************************************
' Receives a message containing an image.
'**************************************************
Public Sub ReceiveMessage()
Try
' Connect to the a queue on the local computer.
Dim myQueue As New MessageQueue(".\myQueue")
' Set the formatter to indicate body contains an Order.
myQueue.Formatter = New BinaryMessageFormatter()
' Receive and format the message.
Dim myMessage As System.Messaging.Message = myQueue.Receive()
Dim myImage As Bitmap = CType(myMessage.Body, Bitmap)
' This will be saved in the \bin\debug or \bin\retail folder.
myImage.Save("ReceivedImage.bmp", System.Drawing.Imaging.ImageFormat.Bmp)
'Catch
' Handle Message Queuing exceptions.
' Handle invalid serialization format.
Catch e As InvalidOperationException
Console.WriteLine(e.Message)
Catch e As IOException
End Try
' Handle file access exceptions.
' Catch other exceptions as necessary.
Return
End Sub 'ReceiveMessage
End Class 'MyNewQueue
End Namespace 'MyProj
using System;
using System.Messaging;
using System.Drawing;
using System.IO;
namespace MyProject
{
/// <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();
// Create a queue on the local computer.
CreateQueue(".\\myQueue");
// Send a message to a queue.
myNewQueue.SendMessage();
// Receive a message from a queue.
myNewQueue.ReceiveMessage();
return;
}
//**************************************************
// Creates a new queue.
//**************************************************
public static void CreateQueue(string queuePath)
{
try
{
if(!MessageQueue.Exists(queuePath))
{
MessageQueue.Create(queuePath);
}
else
{
Console.WriteLine(queuePath + " already exists.");
}
}
catch (MessageQueueException e)
{
Console.WriteLine(e.Message);
}
}
//**************************************************
// Sends an image to a queue, using the BinaryMessageFormatter.
//**************************************************
public void SendMessage()
{
try{
// Create a new bitmap.
// The file must be in the \bin\debug or \bin\retail folder, or
// you must give a full path to its location.
Image myImage = Bitmap.FromFile("SentImage.bmp");
// Connect to a queue on the local computer.
MessageQueue myQueue = new MessageQueue(".\\myQueue");
Message myMessage = new Message(myImage, new BinaryMessageFormatter());
// Send the image to the queue.
myQueue.Send(myMessage);
}
catch(ArgumentException e)
{
Console.WriteLine(e.Message);
}
return;
}
//**************************************************
// Receives a message containing an image.
//**************************************************
public void ReceiveMessage()
{
try
{
// 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 BinaryMessageFormatter();
// Receive and format the message.
System.Messaging.Message myMessage = myQueue.Receive();
Bitmap myImage = (Bitmap)myMessage.Body;
// This will be saved in the \bin\debug or \bin\retail folder.
myImage.Save("ReceivedImage.bmp",System.Drawing.Imaging.ImageFormat.Bmp);
}
catch (MessageQueueException)
{
// Handle Message Queuing exceptions.
}
// Handle invalid serialization format.
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
catch (IOException e)
{
// Handle file access exceptions.
}
// Catch other exceptions as necessary.
return;
}
}
}
#using <system.dll>
#using <system.messaging.dll>
#using <system.drawing.dll>
using namespace System;
using namespace System::Messaging;
using namespace System::Drawing;
using namespace System::IO;
/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:
//*************************************************
// Creates a new queue.
//*************************************************
static void CreateQueue( String^ queuePath )
{
try
{
if ( !MessageQueue::Exists( queuePath ) )
{
MessageQueue::Create( queuePath );
}
else
{
Console::WriteLine( "{0} already exists.", queuePath );
}
}
catch ( MessageQueueException^ e )
{
Console::WriteLine( e->Message );
}
}
//*************************************************
// Sends an image to a queue, using the BinaryMessageFormatter.
//*************************************************
void SendMessage()
{
try
{
// Create a new bitmap.
// The file must be in the \bin\debug or \bin\retail folder, or
// you must give a full path to its location.
Image^ myImage = Bitmap::FromFile( "SentImage::bmp" );
// Connect to a queue on the local computer.
MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
Message^ myMessage = gcnew Message( myImage,gcnew BinaryMessageFormatter );
// Send the image to the queue.
myQueue->Send( myMessage );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e->Message );
}
return;
}
//*************************************************
// Receives a message containing an image.
//*************************************************
void ReceiveMessage()
{
try
{
// Connect to the a queue on the local computer.
MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
// Set the formatter to indicate body contains an Order.
myQueue->Formatter = gcnew BinaryMessageFormatter;
// Receive and format the message.
Message^ myMessage = myQueue->Receive();
Bitmap^ myImage = static_cast<Bitmap^>(myMessage->Body);
// This will be saved in the \bin\debug or \bin\retail folder.
myImage->Save( "ReceivedImage::bmp", System::Drawing::Imaging::ImageFormat::Bmp );
}
catch ( MessageQueueException^ )
{
// Handle Message Queuing exceptions.
}
// Handle invalid serialization format.
catch ( InvalidOperationException^ e )
{
Console::WriteLine( e->Message );
}
catch ( IOException^ e )
{
// Handle file access exceptions.
}
// 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;
// Create a queue on the local computer.
MyNewQueue::CreateQueue( ".\\myQueue" );
// 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.*;
import System.Drawing.*;
import System.IO.*;
/// <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();
// Create a queue on the local computer.
CreateQueue(".\\myQueue");
// Send a message to a queue.
myNewQueue.SendMessage();
// Receive a message from a queue.
myNewQueue.ReceiveMessage();
return;
} //main
//**************************************************
// Creates a new queue.
//**************************************************
public static void CreateQueue(String queuePath)
{
try {
if (!(MessageQueue.Exists(queuePath))) {
MessageQueue.Create(queuePath);
}
else {
Console.WriteLine(queuePath + " already exists.");
}
}
catch (MessageQueueException e) {
Console.WriteLine(e.get_Message());
}
} //CreateQueue
//**************************************************
// Sends an image to a queue, using the BinaryMessageFormatter.
//**************************************************
public void SendMessage()
{
try {
// Create a new bitmap.
// The file must be in the \bin\debug or \bin\retail folder, or
// you must give a full path to its location.
Image myImage = Bitmap.FromFile("SentImage.bmp");
// Connect to a queue on the local computer.
MessageQueue myQueue = new MessageQueue(".\\myQueue");
Message myMessage = new Message(myImage,
new BinaryMessageFormatter());
// Send the image to the queue.
myQueue.Send(myMessage);
}
catch (ArgumentException e) {
Console.WriteLine(e.get_Message());
}
return;
} //SendMessage
//**************************************************
// Receives a message containing an image.
//**************************************************
public void ReceiveMessage()
{
try {
// 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 BinaryMessageFormatter());
// Receive and format the message.
System.Messaging.Message myMessage = myQueue.Receive();
Bitmap myImage = (Bitmap)myMessage.get_Body();
// This will be saved in the \bin\debug or \bin\retail folder.
myImage.Save("ReceivedImage.bmp",
System.Drawing.Imaging.ImageFormat.get_Bmp());
}
catch (MessageQueueException exp) {
// Handle Message Queuing exceptions.
}
// Handle invalid serialization format.
catch (InvalidOperationException e) {
Console.WriteLine(e.get_Message());
}
catch (IOException e) {
// Handle file access exceptions.
}
// Catch other exceptions as necessary.
return;
} //ReceiveMessage
} //MyNewQueue
Im folgenden Codebeispiel wird das Formatieren eines Meldungstextes mithilfe des XmlMessageFormatter veranschaulicht.
Imports System
Imports System.Messaging
Imports System.Drawing
Imports System.IO
' 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
' Provides a container class for the example.
Public Class MyNewQueue
' Provides an entry point into the application.
'
' This example sends and receives a message from
' a queue.
Public Shared Sub Main()
' Create a new instance of the class.
Dim myNewQueue As New MyNewQueue()
' Create a queue on the local computer.
CreateQueue(".\myQueue")
' Send a message to a queue.
myNewQueue.SendMessage()
' Receive a message from a queue.
myNewQueue.ReceiveMessage()
Return
End Sub 'Main
' Creates a new queue.
Public Shared Sub CreateQueue(queuePath As String)
Try
If Not MessageQueue.Exists(queuePath) Then
MessageQueue.Create(queuePath)
Else
Console.WriteLine((queuePath + " already exists."))
End If
Catch e As MessageQueueException
Console.WriteLine(e.Message)
End Try
End Sub 'CreateQueue
' Sends an Order to a queue.
Public Sub SendMessage()
Try
' 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")
' Create the new order.
Dim myMessage As New Message(sentOrder)
' Send the order to the queue.
myQueue.Send(myMessage)
Catch e As ArgumentException
Console.WriteLine(e.Message)
End Try
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 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()))
' Handle invalid serialization format.
Catch e As InvalidOperationException
Console.WriteLine(e.Message)
End Try
' Catch other exceptions as necessary.
Return
End Sub 'ReceiveMessage
End Class 'MyNewQueue
using System;
using System.Messaging;
using System.Drawing;
using System.IO;
namespace MyProject
{
// 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();
// Create a queue on the local computer.
CreateQueue(".\\myQueue");
// Send a message to a queue.
myNewQueue.SendMessage();
// Receive a message from a queue.
myNewQueue.ReceiveMessage();
return;
}
//**************************************************
// Creates a new queue.
//**************************************************
public static void CreateQueue(string queuePath)
{
try
{
if(!MessageQueue.Exists(queuePath))
{
MessageQueue.Create(queuePath);
}
else
{
Console.WriteLine(queuePath + " already exists.");
}
}
catch (MessageQueueException e)
{
Console.WriteLine(e.Message);
}
}
//**************************************************
// Sends an Order to a queue.
//**************************************************
public void SendMessage()
{
try
{
// 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");
// Create the new order.
Message myMessage = new Message(sentOrder);
// Send the order to the queue.
myQueue.Send(myMessage);
}
catch(ArgumentException e)
{
Console.WriteLine(e.Message);
}
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 <system.drawing.dll>
using namespace System;
using namespace System::Messaging;
using namespace System::Drawing;
using namespace System::IO;
ref class Order
{
public:
int orderId;
DateTime orderTime;
};
ref class MyNewQueue
{
public:
static void CreateQueue( String^ queuePath )
{
try
{
if ( !MessageQueue::Exists( queuePath ) )
{
MessageQueue::Create( queuePath );
}
else
{
Console::WriteLine( "{0} already exists.", queuePath );
}
}
catch ( MessageQueueException^ e )
{
Console::WriteLine( e->Message );
}
}
void SendMessage()
{
try
{
// 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" );
// Create the new order.
Message^ myMessage = gcnew Message( sentOrder );
// Send the order to the queue.
myQueue->Send( myMessage );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e->Message );
}
return;
}
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 = dynamic_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;
}
};
int main()
{
// Create a new instance of the class.
MyNewQueue^ myNewQueue = gcnew MyNewQueue;
// Create a queue on the local computer.
MyNewQueue::CreateQueue( ".\\myQueue" );
// 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.*;
import System.Drawing.*;
import System.IO.*;
// 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();
// Create a queue on the local computer.
CreateQueue(".\\myQueue");
// Send a message to a queue.
myNewQueue.SendMessage();
// Receive a message from a queue.
myNewQueue.ReceiveMessage();
return;
} //main
//**************************************************
// Creates a new queue.
//**************************************************
public static void CreateQueue(String queuePath)
{
try {
if (!(MessageQueue.Exists(queuePath))) {
MessageQueue.Create(queuePath);
}
else {
Console.WriteLine(queuePath + " already exists.");
}
}
catch (MessageQueueException e) {
Console.WriteLine(e.get_Message());
}
} //CreateQueue
//**************************************************
// Sends an Order to a queue.
//**************************************************
public void SendMessage()
{
try {
// 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");
// Create the new order.
Message myMessage = new Message(sentOrder);
// Send the order to the queue.
myQueue.Send(myMessage);
}
catch (ArgumentException e) {
Console.WriteLine(e.get_Message());
}
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: " + Convert.ToString(myOrder.orderId));
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.Message
Threadsicherheit
Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
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
Message-Member
System.Messaging-Namespace
MessageQueue
DefaultPropertiesToSend-Klasse
Send
Receive
Peek