Message Klasse

Referenz

Definition

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt den Zugriff auf die Eigenschaften bereit, die zur Definition einer Message Queuing-Meldung erforderlich sind.

public ref class Message : System::ComponentModel::Component

public class Message : System.ComponentModel.Component

type Message = class
    inherit Component

Public Class Message
Inherits Component

Vererbung: Object

MarshalByRefObject

Component
Message

Beispiele

Im folgenden Codebeispiel wird die Formatierung eines Nachrichtentexts mithilfe von BinaryMessageFormatter.

#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

Im folgenden Codebeispiel wird die Formatierung eines Nachrichtentexts mithilfe von XmlMessageFormatter.

#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 die Message Klasse, um Nachrichten aus einer Warteschlange anzuzeigen oder zu empfangen, oder um beim Senden einer Nachricht an eine Warteschlange eine feine Kontrolle über Nachrichteneigenschaften zu haben.

MessageQueueverwendet die Message Klasse, wenn sie Nachrichten aus Warteschlangen anzeigt oder empfängt, da sowohl die Methoden MessageQueue.Receive als auch die MessageQueue.Peek Methoden eine neue Instanz der Klasse erstellen und die Eigenschaften der Message Instanz festlegen. Die schreibgeschützten Eigenschaften der Message Klasse gelten für das Abrufen von Nachrichten aus einer Warteschlange, während die Lese-/Schreibeigenschaften zum Senden und Abrufen von Nachrichten gelten. Wenn MessageQueue Sie eine Nachricht aus einer Warteschlange anzeigen oder empfangen, bestimmt ihre MessageReadPropertyFilter Eigenschaft, welche eigenschaften der Nachricht abgerufen werden.

Mit der MessageQueue Methode der Send Klasse können Sie einen beliebigen Objekttyp für eine Nachricht angeben, die an diese Warteschlange gesendet wird. Sie können die Eigenschaft der MessageQueue Instanz DefaultPropertiesToSend verwenden, um Einstellungen für generische Nachrichten anzugeben, die an die Warteschlange gesendet werden. Die Arten von Einstellungen umfassen Formatierer, Bezeichnung, Verschlüsselung und Authentifizierung. Sie können auch Werte für die entsprechenden DefaultPropertiesToSend Mitglieder angeben, wenn Sie Ihre Messaginganwendung koordinieren, um auf Bestätigungs- und Berichtsnachrichten zu reagieren. Die Verwendung einer Instanz zum Senden einer Nachricht an die Warteschlange bietet Ihnen die Flexibilität, auf viele Message dieser Eigenschaften zuzugreifen und zu ändern – entweder für eine einzelne Nachricht oder auf nachrichtenweiser Basis. Message Eigenschaften haben Vorrang vor DefaultPropertiesToSend.

Nachrichtendaten werden in der Body Eigenschaft und in geringerem Umfang gespeichert, die AppSpecific und Extension die Eigenschaften. Wenn Nachrichtendaten verschlüsselt, serialisiert oder deserialisiert werden, sind nur die Inhalte der Body Eigenschaft betroffen.

Der Inhalt der Body Eigenschaft wird serialisiert, wenn die Nachricht gesendet wird, mithilfe der Formatter von Ihnen angegebenen Eigenschaft. Der serialisierte Inhalt befindet sich in der BodyStream Eigenschaft. Sie können die BodyStream Eigenschaft auch direkt festlegen, um z. B. eine Datei als Dateninhalt einer Nachricht zu senden. Sie können die Body Eigenschaften Formatter jederzeit ändern, bevor Sie die Nachricht senden, und die Daten werden entsprechend serialisiert, wenn Sie die Nachricht aufrufen Send.

Die durch die MessageQueue.DefaultPropertiesToSend Eigenschaft definierten Eigenschaften gelten nur für Nachrichten, die nicht vom Typ sind Message. Wenn Sie die DefaultPropertiesToSend Eigenschaft für eine MessageQueueangeben, werden die identisch benannten Eigenschaften in einer Instanz, die an diese Message Warteschlange gesendet wird, dazu führen, dass diese Standardeigenschaften ignoriert werden.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von Message, finden Sie im Message Konstruktor.

Konstruktoren

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.

Felder

InfiniteTimeout

Gibt an, dass kein Timeout vorhanden ist.

Eigenschaften

AcknowledgeType	Ruft den Typ der Bestätigungsmeldung ab, die an die sendende Anwendung zurückgegeben werden soll, oder legt diesen fest.
Acknowledgment	Ruft die Klassifikation für die Bestätigung ab, die diese Meldung darstellt.
AdministrationQueue	Ruft die Warteschlange ab, die die von Message Queuing erzeugten Bestätigungsmeldungen empfängt, oder legt diese fest.
AppSpecific	Ruft zusätzliche anwendungsspezifische Daten ab oder legt diese fest.
ArrivedTime	Ruft den Zeitpunkt ab, zu dem die Meldung von der Zielwarteschlange empfangen wurde.
AttachSenderId	Ruft einen Wert ab, der angibt, ob die Sender-ID an die Meldung angehängt werden soll, oder legt diesen fest.
Authenticated	Ruft einen Wert ab, der angibt, ob die Nachricht authentifiziert wurde.
AuthenticationProviderName	Ruft den Namen des Kryptografieanbieters ab, der zum Generieren der digitalen Signatur für die Meldung verwendet wird.
AuthenticationProviderType	Ruft den Typ des Kryptografieanbieters ab, mit dem die digitale Signatur der Meldung generiert wird, oder legt diesen fest.
Body	Ruft den Inhalt der Nachricht ab oder legt diesen fest.
BodyStream	Ruft die Daten im Meldungstext ab oder legt diese fest.
BodyType	Ruft den Typ der im Nachrichtenkörper enthaltenen Daten ab oder legt diesen fest.
CanRaiseEvents	Ruft einen Wert ab, der angibt, ob die Komponente ein Ereignis auslösen kann. (Geerbt von Component)
ConnectorType	Ruft einen Wert ab, der anzeigt, dass einige Meldungseigenschaften, die normalerweise von Message Queuing festgelegt werden, durch die sendende Anwendung festgelegt wurden, oder legt diesen fest.
Container	Ruft die IContainer ab, die in der Component enthalten ist. (Geerbt von Component)
CorrelationId	Ruft die in Bestätigungs-, Berichts- und Antwortnachrichten für den Verweis auf die ursprüngliche Nachricht verwendete Nachrichten-ID ab oder legt diese fest.
DesignMode	Ruft einen Wert ab, der angibt, ob sich Component gegenwärtig im Entwurfsmodus befindet. (Geerbt von Component)
DestinationQueue	Ruft die für eine Meldung angegebene Zielwarteschlange ab.
DestinationSymmetricKey	Ruft den symmetrischen Schlüssel für Meldungen ab, die in einer Anwendung oder für die Übermittlung an fremde Warteschlangen verschlüsselt werden.
DigitalSignature	Ruft die digitale Signatur ab, mit der Message Queuing die Meldung authentifiziert, oder legt diese fest.
EncryptionAlgorithm	Ruft den Verschlüsselungsalgorithmus ab, der zum Verschlüsseln des Meldungstextes einer privaten Meldung verwendet wird, oder legt diesen fest.
Events	Ruft die Liste der Ereignishandler ab, die dieser Component angefügt sind. (Geerbt von Component)
Extension	Ruft weitere anwendungsspezifische, der Nachricht zugeordnete Informationen ab oder legt diese fest.
Formatter	Ruft den Formatierer ab, der zum Serialisieren und Deserialisieren eines Objekts in bzw. aus dem Nachrichtenkörper verwendet wird.
HashAlgorithm	Ruft den zur Authentifizierung oder zur Erzeugung der digitalen Signatur einer Meldung von Message Queuing verwendeten Hashalgorithmus ab oder legt diesen fest.
Id	Ruft die ID der Nachricht ab.
IsFirstInTransaction	Ruft einen Wert ab, der angibt, ob die Meldung als erste Meldung in einer Transaktion gesendet wurde.
IsLastInTransaction	Ruft einen Wert ab, der angibt, ob die Meldung als letzte Meldung in einer Transaktion gesendet wurde.
Label	Ruft eine von der Anwendung definierte Unicode-Zeichenfolge ab, die die Nachricht beschreibt, oder legt diese fest.
LookupId	Eingeführt in MSMQ 3.0. Ruft den Suchbezeichner der Meldung ab.
MessageType	Ruft den Nachrichtentyp ab: `Normal`, `Acknowledgment` oder `Report`.
Priority	Ruft die Nachrichtenpriorität ab, die die Position der Nachricht in der Warteschlange bestimmt, oder legt diese fest.
Recoverable	Ruft einen Wert ab, der angibt, ob die Zustellung einer Meldung im Falle eines Computerfehlers oder Netzwerkproblems sichergestellt ist, oder legt diesen fest.
ResponseQueue	Ruft die Warteschlange ab, die von einer Anwendung generierte Antwortnachrichten empfängt, oder legt diese fest.
SecurityContext	Ruft den Sicherheitskontext für eine Meldung ab oder legt diesen fest.
SenderCertificate	Ruft das zum Authentifizieren von Meldungen verwendete Sicherheitszertifikat ab oder legt dieses fest.
SenderId	Ruft die ID des sendenden Benutzers ab.
SenderVersion	Ruft die Version von Message Queuing ab, mit der die Meldung gesendet wurde.
SentTime	Ruft Datum und Uhrzeit auf dem sendenden Computer ab, zu der die Nachricht vom Quellwarteschlangen-Manager gesendet wurde.
Site	Ruft den ISite von Component ab oder legt ihn fest. (Geerbt von Component)
SourceMachine	Ruft den Computer ab, von dem die Meldung ausging.
TimeToBeReceived	Ruft die Zeitbegrenzung für den Empfang der Meldung aus der Zielwarteschlange ab oder legt diese fest.
TimeToReachQueue	Ruft die Zeitbegrenzung der Nachricht für das Erreichen der Warteschlange ab oder legt diese fest.
TransactionId	Ruft die ID der Transaktion ab, in der die Meldung gesendet wurde.
TransactionStatusQueue	Ruft die Transaktionsstatus-Warteschlange auf dem Quellcomputer ab.
UseAuthentication	Ruft einen Wert ab, der angibt, ob die Meldung vor dem Absenden authentifiziert wurde oder authentifiziert werden muss, oder legt diesen fest.
UseDeadLetterQueue	Ruft einen Wert ab, der angibt, ob eine Kopie der nicht zustellbaren Meldung an eine Dead Letter-Warteschlange gesendet werden soll, oder legt diesen fest.
UseEncryption	Ruft einen Wert ab, der angibt, ob die Meldung als privat behandelt werden soll, oder legt diesen fest.
UseJournalQueue	Ruft einen Wert ab, der angibt, ob eine Kopie der Meldung in einem Journal auf dem sendenden Computer abgelegt werden soll, oder legt diesen fest.
UseTracing	Ruft einen Wert ab, der angibt, ob eine Meldung während der Weiterleitung an die Zielwarteschlange verfolgt wird, oder legt diesen fest.

Methoden

CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
Dispose()	Gibt alle vom Component verwendeten Ressourcen frei. (Geerbt von Component)
Dispose(Boolean)	Gibt die von Component verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. (Geerbt von Component)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetService(Type)	Gibt ein Objekt zurück, das einen von der Component oder von deren Container bereitgestellten Dienst darstellt. (Geerbt von Component)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
ToString()	Gibt einen String zurück, der den Namen der Component enthält (sofern vorhanden). Diese Methode darf nicht überschrieben werden. (Geerbt von Component)

Ereignisse

Disposed

Tritt auf, wenn die Komponente von einem Aufruf der Dispose()-Methode verworfen wird.

(Geerbt von Component)

Gilt für