Message Konstruktoren
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Initialisiert eine neue Instanz der Message-Klasse.
Überlädt
Message() |
Initialisiert eine neue Instanz der Message-Klasse mit einem leeren Meldungstext. |
Message(Object) |
Initialisiert eine neue Instanz der Message-Klasse, wobei das angegebene Objekt mithilfe des XmlMessageFormatter in den Meldungstext serialisiert wird. |
Message(Object, IMessageFormatter) |
Initialisiert eine neue Instanz der Message-Klasse, wobei das angegebene Objekt mithilfe des angegebenen Formatierers in den Meldungstext serialisiert wird. |
Message()
Initialisiert eine neue Instanz der Message-Klasse mit einem leeren Meldungstext.
public:
Message();
public Message ();
Public Sub New ()
Beispiele
Im folgenden Codebeispiel werden zwei Nachrichten unterschiedlicher Prioritäten an die Warteschlange gesendet und anschließend abgerufen.
#using <system.dll>
#using <system.messaging.dll>
using namespace System;
using namespace System::Messaging;
/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
//**************************************************
// Sends a string message to a queue.
//**************************************************
public:
void SendMessage( MessagePriority priority, String^ messageBody )
{
// Connect to a queue on the local computer.
MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
// Create a new message.
Message^ myMessage = gcnew Message;
if ( priority > MessagePriority::Normal )
{
myMessage->Body = "High Priority: {0}",messageBody;
}
else
{
myMessage->Body = messageBody;
}
// Set the priority of the message.
myMessage->Priority = priority;
// Send the Order to the queue.
myQueue->Send( myMessage );
return;
}
//**************************************************
// Receives a message.
//**************************************************
void ReceiveMessage()
{
// Connect to the a queue on the local computer.
MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
// Set the queue to read the priority. By default, it
// is not read.
myQueue->MessageReadPropertyFilter->Priority = true;
// Set the formatter to indicate body contains a String^.
array<Type^>^ p = gcnew array<Type^>(1);
p[ 0 ] = String::typeid;
myQueue->Formatter = gcnew XmlMessageFormatter( p );
try
{
// Receive and format the message.
Message^ myMessage = myQueue->Receive();
// Display message information.
Console::WriteLine( "Priority: {0}",
myMessage->Priority );
Console::WriteLine( "Body: {0}",
myMessage->Body );
}
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 messages to a queue.
myNewQueue->SendMessage( MessagePriority::Normal, "First Message Body." );
myNewQueue->SendMessage( MessagePriority::Highest, "Second Message Body." );
// Receive messages from a queue.
myNewQueue->ReceiveMessage();
myNewQueue->ReceiveMessage();
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 sends and receives a message from
// a queue.
//**************************************************
public static void Main()
{
// Create a new instance of the class.
MyNewQueue myNewQueue = new MyNewQueue();
// Send messages to a queue.
myNewQueue.SendMessage(MessagePriority.Normal, "First Message Body.");
myNewQueue.SendMessage(MessagePriority.Highest, "Second Message Body.");
// Receive messages from a queue.
myNewQueue.ReceiveMessage();
myNewQueue.ReceiveMessage();
return;
}
//**************************************************
// Sends a string message to a queue.
//**************************************************
public void SendMessage(MessagePriority priority, string messageBody)
{
// Connect to a queue on the local computer.
MessageQueue myQueue = new MessageQueue(".\\myQueue");
// Create a new message.
Message myMessage = new Message();
if(priority > MessagePriority.Normal)
{
myMessage.Body = "High Priority: " + messageBody;
}
else
{
myMessage.Body = messageBody;
}
// Set the priority of the message.
myMessage.Priority = priority;
// Send the Order to the queue.
myQueue.Send(myMessage);
return;
}
//**************************************************
// Receives a message.
//**************************************************
public void ReceiveMessage()
{
// Connect to the a queue on the local computer.
MessageQueue myQueue = new MessageQueue(".\\myQueue");
// Set the queue to read the priority. By default, it
// is not read.
myQueue.MessageReadPropertyFilter.Priority = true;
// Set the formatter to indicate body contains a string.
myQueue.Formatter = new XmlMessageFormatter(new Type[]
{typeof(string)});
try
{
// Receive and format the message.
Message myMessage = myQueue.Receive();
// Display message information.
Console.WriteLine("Priority: " +
myMessage.Priority.ToString());
Console.WriteLine("Body: " +
myMessage.Body.ToString());
}
catch (MessageQueueException)
{
// Handle Message Queuing exceptions.
}
// Handle invalid serialization format.
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
// Catch other exceptions as necessary.
return;
}
}
}
Imports System.Messaging
'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()
' Send messages to a queue.
myNewQueue.SendMessage(MessagePriority.Normal, "First Message Body.")
myNewQueue.SendMessage(MessagePriority.Highest, "Second Message Body.")
' Receive messages from a queue.
myNewQueue.ReceiveMessage()
myNewQueue.ReceiveMessage()
Return
End Sub
' Sends a string message to a queue.
Public Sub SendMessage(priority As MessagePriority, messageBody As String)
' Connect to a queue on the local computer.
Dim myQueue As New MessageQueue(".\myQueue")
' Create a new message.
Dim myMessage As New Message()
If priority > MessagePriority.Normal Then
myMessage.Body = "High Priority: " + messageBody
Else
myMessage.Body = messageBody
End If
' Set the priority of the message.
myMessage.Priority = priority
' Send the Order to the queue.
myQueue.Send(myMessage)
Return
End Sub
' Receives a message.
Public Sub ReceiveMessage()
' Connect to the a queue on the local computer.
Dim myQueue As New MessageQueue(".\myQueue")
' Set the queue to read the priority. By default, it
' is not read.
myQueue.MessageReadPropertyFilter.Priority = True
' Set the formatter to indicate body contains a string.
myQueue.Formatter = New XmlMessageFormatter(New Type() {GetType(String)})
Try
' Receive and format the message.
Dim myMessage As Message = myQueue.Receive()
' Display message information.
Console.WriteLine(("Priority: " + myMessage.Priority.ToString()))
Console.WriteLine(("Body: " + myMessage.Body.ToString()))
' Handle invalid serialization format.
Catch e As InvalidOperationException
Console.WriteLine(e.Message)
End Try
' Catch other exceptions as necessary.
Return
End Sub
End Class
Hinweise
Verwenden Sie diese Überladung, um eine neue Instanz der Message Klasse mit einem leeren Textkörper zu erstellen.
Geben Sie entweder die Body Eigenschaft oder die BodyStream Eigenschaft an, bevor Sie das Message Objekt senden. Die Body Eigenschaft kann ein beliebiges Objekt sein, das serialisiert werden kann, z. B. eine Textzeichenfolge, ein Strukturobjekt, eine Klasseninstanz oder ein eingebettetes Objekt.
Wenn Sie den Inhalt der Nachricht nicht direkt in die BodyStream Eigenschaft schreiben, legen Sie die Formatter Eigenschaft fest, bevor Sie die Nachricht senden. Der Textkörper wird mithilfe des Werts der Formatter Eigenschaft zum Zeitpunkt des Aufrufs der Send Methode für die MessageQueue Instanz serialisiert.
Dies XmlMessageFormatter ist lose gekoppelt, daher ist es nicht erforderlich, bei Verwendung dieses Formats denselben Objekttyp auf dem Absender und Empfänger zu haben. Die ActiveXMessageFormatter Daten werden BinaryMessageFormatter in binäre Darstellung serialisiert. Dies ActiveXMessageFormatter wird beim Senden oder Empfangen von COM-Komponenten verwendet.
In der folgenden Tabelle sind die anfänglichen Eigenschaftswerte für eine Instanz von Message.
Eigenschaft | Anfangswert |
---|---|
AcknowledgeType | AcknowledgeType.None |
AdministrationQueue | null |
AppSpecific | 0 |
AttachSenderId | true |
AuthenticationProviderName | Microsoft Base-Kryptografieanbieter, Version 1.0 |
AuthenticationProviderType | CryptoProviderType.RSA_FULL |
Body | null |
BodyStream | Stream.null |
BodyType | 0 |
ConnectorType | Guid.Empty |
CorrelationId | Eine leere Zeichenfolge ("") |
DestinationSymmetricKey | Ein Nulllängenarray von Bytes |
DigitalSignature | Ein Nulllängenarray von Bytes |
EncryptionAlgorithm | EncryptionAlgorithm.RC2 |
Extension | Ein Nulllängenarray von Bytes |
Formatter | XmlMessageFormatter |
HashAlgorithm | HashAlgorithm.MD5 |
Label | Eine leere Zeichenfolge ("") |
Priority | MessagePriority.Normal |
Recoverable | false |
ResponseQueue | null |
SenderCertificate | Ein Nulllängenarray von Bytes |
TimeToBeReceived | Message.InfiniteTimeout |
TimeToReachQueue | Message.InfiniteTimeout |
TransactionStatusQueue | null |
UseAuthentication | false |
UseDeadLetterQueue | false |
UseEncryption | false |
UseJournalQueue | false |
UseTracing | false |
Siehe auch
Gilt für
Message(Object)
Initialisiert eine neue Instanz der Message-Klasse, wobei das angegebene Objekt mithilfe des XmlMessageFormatter in den Meldungstext serialisiert wird.
public:
Message(System::Object ^ body);
public Message (object body);
new System.Messaging.Message : obj -> System.Messaging.Message
Public Sub New (body As Object)
Parameter
- body
- Object
Das Objekt, das in den Meldungstext serialisiert werden soll.
Beispiele
Im folgenden Codebeispiel wird eine neue Warteschlange erstellt, eine Nachricht gesendet, die eine Reihenfolge enthält, und ruft sie dann ab.
#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;
}
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;
}
}
}
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
' 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
' 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
' 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
' 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
End Class
Hinweise
Verwenden Sie diese Überladung, um eine neue Instanz der Klasse zu erstellen, die Message den body
Body vom Parameter angegebenen Wert enthält. Der body
Parameter kann ein beliebiges Objekt sein, das serialisiert werden kann, z. B. eine Textzeichenfolge, ein Strukturobjekt, eine Klasseninstanz oder ein eingebettetes Objekt. Der Textkörper wird serialisiert, XmlMessageFormatter es sei denn, Sie ändern die Formatter Eigenschaft, bevor sie Message gesendet wird. Wenn Sie die Body Formatter Eigenschaft jederzeit vor dem Aufrufen Sendändern, wird die Nachricht entsprechend dem neuen Eigenschaftswert serialisiert.
Dies XmlMessageFormatter ist lose gekoppelt, daher ist es nicht erforderlich, bei Verwendung dieses Formats denselben Objekttyp auf dem Absender und Empfänger zu haben. Die ActiveXMessageFormatter Daten werden BinaryMessageFormatter in binäre Darstellung serialisiert. Dies ActiveXMessageFormatter wird beim Senden oder Empfangen von COM-Komponenten verwendet.
In der folgenden Tabelle sind die anfänglichen Eigenschaftswerte für eine Instanz von Message.
Eigenschaft | Anfangswert |
---|---|
AcknowledgeType | AcknowledgeType.None |
AdministrationQueue | null |
AppSpecific | 0 |
AttachSenderId | true |
AuthenticationProviderName | Microsoft Base-Kryptografieanbieter, Version 1.0 |
AuthenticationProviderType | CryptoProviderType.RSA_FULL |
Body | Der body -Parameter. |
BodyStream | Stream.null |
BodyType | 0 |
ConnectorType | Guid.Empty |
CorrelationId | Eine leere Zeichenfolge ("") |
DestinationSymmetricKey | Ein Nulllängenarray von Bytes |
DigitalSignature | Ein Nulllängenarray von Bytes |
EncryptionAlgorithm | EncryptionAlgorithm.RC2 |
Extension | Ein Nulllängenarray von Bytes |
Formatter | XmlMessageFormatter |
HashAlgorithm | HashAlgorithm.MD5 |
Label | Eine leere Zeichenfolge ("") |
Priority | MessagePriority.Normal |
Recoverable | false |
ResponseQueue | null |
SenderCertificate | Ein Nulllängenarray von Bytes |
TimeToBeReceived | Message.InfiniteTimeout |
TimeToReachQueue | Message.InfiniteTimeout |
TransactionStatusQueue | null |
UseAuthentication | false |
UseDeadLetterQueue | false |
UseEncryption | false |
UseJournalQueue | false |
UseTracing | false |
Siehe auch
Gilt für
Message(Object, IMessageFormatter)
Initialisiert eine neue Instanz der Message-Klasse, wobei das angegebene Objekt mithilfe des angegebenen Formatierers in den Meldungstext serialisiert wird.
public:
Message(System::Object ^ body, System::Messaging::IMessageFormatter ^ formatter);
public Message (object body, System.Messaging.IMessageFormatter formatter);
new System.Messaging.Message : obj * System.Messaging.IMessageFormatter -> System.Messaging.Message
Public Sub New (body As Object, formatter As IMessageFormatter)
Parameter
- body
- Object
Das Objekt, das in den Meldungstext serialisiert werden soll.
- formatter
- IMessageFormatter
Der IMessageFormatter gibt den Formatierer an, mit dem die Serialisierung in den Meldungstext erfolgen soll.
Beispiele
#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;
}
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;
}
}
}
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
'**************************************************
' 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
'**************************************************
' 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
'**************************************************
' 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
End Class
End Namespace 'MyProj
Hinweise
Verwenden Sie diese Überladung, um eine neue Instanz der Klasse zu erstellen, die Message den body
Body angegebenen Parameter enthält und einen gültigen Formatierer zum Serialisieren des Textkörpers verwendet. Der body
Parameter ist ein beliebiges Objekt, das serialisiert werden kann, z. B. eine Textzeichenfolge, ein Strukturobjekt, eine Klasseninstanz oder ein eingebettetes Objekt. Wenn Sie die Body Formatter Eigenschaft jederzeit vor dem Aufrufen Sendändern, wird die Nachricht entsprechend dem neuen Eigenschaftswert serialisiert.
Dies XmlMessageFormatter ist lose gekoppelt, daher ist es nicht erforderlich, bei Verwendung dieses Formats denselben Objekttyp auf dem Absender und Empfänger zu haben. Die ActiveXMessageFormatter Daten werden BinaryMessageFormatter in binäre Darstellung serialisiert. Dies ActiveXMessageFormatter wird beim Senden oder Empfangen von COM-Komponenten verwendet.
In der folgenden Tabelle sind die anfänglichen Eigenschaftswerte für eine Instanz von Message.
Eigenschaft | Anfangswert |
---|---|
AcknowledgeType | AcknowledgeType.None |
AdministrationQueue | null |
AppSpecific | 0 |
AttachSenderId | true |
AuthenticationProviderName | Microsoft Base-Kryptografieanbieter, Version 1.0 |
AuthenticationProviderType | CryptoProviderType.RSA_FULL |
Body | Der body -Parameter. |
BodyStream | Stream.null |
BodyType | 0 |
ConnectorType | Guid.Empty |
CorrelationId | Eine leere Zeichenfolge ("") |
DestinationSymmetricKey | Ein Nulllängenarray von Bytes |
DigitalSignature | Ein Nulllängenarray von Bytes |
EncryptionAlgorithm | EncryptionAlgorithm.RC2 |
Extension | Ein Nulllängenarray von Bytes |
Formatter | Der formatter -Parameter. |
HashAlgorithm | HashAlgorithm.MD5 |
Label | Eine leere Zeichenfolge ("") |
Priority | MessagePriority.Normal |
Recoverable | false |
ResponseQueue | null |
SenderCertificate | Ein Nulllängenarray von Bytes |
TimeToBeReceived | Message.InfiniteTimeout |
TimeToReachQueue | Message.InfiniteTimeout |
TransactionStatusQueue | null |
UseAuthentication | false |
UseDeadLetterQueue | false |
UseEncryption | false |
UseJournalQueue | false |
UseTracing | false |
Siehe auch
- XmlMessageFormatter
- BinaryMessageFormatter
- ActiveXMessageFormatter
- DefaultPropertiesToSend
- MessageQueue
- Send(Object)
- Peek()
- Receive()