Message Message Message Message Class

Definition

Stellt den Zugriff auf die Eigenschaften bereit, die zur Definition einer Message Queuing-Meldung erforderlich sind.Provides access to the properties needed to define a Message Queuing message.

public ref class Message : System::ComponentModel::Component
public class Message : System.ComponentModel.Component
type Message = class
    inherit Component
Public Class Message
Inherits Component
Vererbung

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie ein Nachrichten BinaryMessageFormatterText mit formatiert wird.The following code example demonstrates formatting a message body using 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 veranschaulicht, wie ein Nachrichten XmlMessageFormatterText mit formatiert wird.The following code example demonstrates formatting a message body using 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 Message die-Klasse, um Nachrichten aus einer Warteschlange zu sehen oder zu empfangen oder um beim Senden einer Nachricht an eine Warteschlange eine genaue Kontrolle über die Nachrichten Eigenschaften zu haben.Use the Message class to peek or receive messages from a queue, or to have fine control over message properties when sending a message to a queue.

MessageQueueverwendet die Message -Klasse, wenn Sie Nachrichten von Warteschlangen empfängt oder empfängt, MessageQueue.Peek da MessageQueue.Receive sowohl die-Methode als auch die Message -Methode eine neue Instanz der-Klasse erstellen und die Eigenschaften der-Instanz festlegen.MessageQueue uses the Message class when it peeks or receives messages from queues, because both the MessageQueue.Peek and MessageQueue.Receive methods create a new instance of the Message class and set the instance's properties. Die Message schreibgeschützten Eigenschaften der-Klasse gelten für das Abrufen von Nachrichten aus einer Warteschlange, während die Lese-/Schreibeigenschaften für das Senden und Abrufen von Nachrichten gelten.The Message class's read-only properties apply to retrieving messages from a queue, while the read/write properties apply to sending and retrieving messages. Wenn MessageQueue ein Peer oder eine Nachricht von einer Warteschlange empfängt MessageReadPropertyFilter , bestimmt die-Eigenschaft, welche der Nachrichten Eigenschaften abgerufen werden.When MessageQueue peeks or receives a message from a queue, its MessageReadPropertyFilter property determines which of the message's properties are retrieved.

Mit MessageQueue der- Send Methode der-Klasse können Sie einen beliebigen Objekttyp für eine Nachricht angeben, die an diese Warteschlange gesendet wird.The MessageQueue class's Send method allows you to specify any object type for a message being sent to that queue. Sie können die- MessageQueue Eigenschaft der DefaultPropertiesToSend -Instanz verwenden, um Einstellungen für generische Meldungen anzugeben, die an die Warteschlange gesendet werden.You can use the MessageQueue instance's DefaultPropertiesToSend property to specify settings for generic messages sent to the queue. Zu den Einstellungs Typen zählen Formatierer, Bezeichnung, Verschlüsselung und Authentifizierung.The types of settings include formatter, label, encryption, and authentication. Sie können auch Werte für die entsprechenden DefaultPropertiesToSend Member angeben, wenn Sie Ihre Messaging Anwendung so koordinieren, dass Sie auf Bestätigungs-und Berichts Nachrichten antwortet.You can also specify values for the appropriate DefaultPropertiesToSend members when you coordinate your messaging application to respond to acknowledgment and report messages. Wenn Sie eine- Instanzverwenden,umeineNachrichtandieWarteschlangezusenden,habenSiedieFlexibilität,aufvieledieserEigenschaftenzuzugreifenunddiesezuändern,entwederfüreineeinzelneNachrichtoderfürNachrichtenNachrichten.MessageUsing a Message instance to send a message to the queue gives you the flexibility to access and modify many of these properties - either for a single message or on a message-by-message basis. MessageEigenschaften haben Vorrang DefaultPropertiesToSendvor.Message properties take precedence over DefaultPropertiesToSend.

Nachrichten Daten werden in der Body -Eigenschaft gespeichert und in geringerem Umfang, der-Eigenschaft und der AppSpecific - Extension Eigenschaft.Message data is stored in the Body property and to a lesser extent, the AppSpecific and Extension properties. Wenn Nachrichten Daten verschlüsselt, serialisiert oder deserialisiert werden, wird nur der Inhalt Body der-Eigenschaft beeinflusst.When message data is encrypted, serialized, or deserialized, only the contents of the Body property are affected.

Der Inhalt Body der-Eigenschaft wird beim Senden der Nachricht mithilfe der Formatter angegebenen Eigenschaft serialisiert.The contents of the Body property are serialized when the message is sent, using the Formatter property you specify. Der serialisierte Inhalt wird in der BodyStream -Eigenschaft gefunden.The serialized contents are found in the BodyStream property. Sie können die BodyStream -Eigenschaft auch direkt festlegen, um z. b. eine Datei als Dateninhalt einer Nachricht zu senden.You can also set the BodyStream property directly, for example, to send a file as the data content of a message. Sie können die- Body Eigenschaft Formatter oder die-Eigenschaft zu einem beliebigen Zeitpunkt vor dem Senden der Nachricht ändern, und die Daten werden entsprechend Sendserialisiert, wenn Sie aufzurufen.You can change the Body or Formatter properties at any time before sending the message, and the data will be serialized appropriately when you call Send.

Die Eigenschaften, die von MessageQueue.DefaultPropertiesToSend der-Eigenschaft definiert werden, gelten nur für nach Messagerichten, die nicht vom Typ sind.The properties defined by the MessageQueue.DefaultPropertiesToSend property apply only to messages that are not of type Message. Wenn Sie die DefaultPropertiesToSend -Eigenschaft für einen MessageQueueangeben, werden diese Standardeigenschaften von den Message identisch benannten Eigenschaften in einer-Instanz, die an diese Warteschlange gesendet werden, ignoriert.If you specify the DefaultPropertiesToSend property for a MessageQueue, the identically named properties in a Message instance sent to that queue cause these default properties to be ignored.

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

Konstruktoren

Message() Message() Message() Message()

Initialisiert eine neue Instanz der Message-Klasse mit einem leeren Meldungstext.Initializes a new instance of the Message class with an empty body.

Message(Object) Message(Object) Message(Object) Message(Object)

Initialisiert eine neue Instanz der Message-Klasse, wobei das angegebene Objekt mithilfe des XmlMessageFormatter in den Meldungstext serialisiert wird.Initializes a new instance of the Message class, using the XmlMessageFormatter to serialize the specified object into the body of the message.

Message(Object, IMessageFormatter) Message(Object, IMessageFormatter) Message(Object, IMessageFormatter) Message(Object, IMessageFormatter)

Initialisiert eine neue Instanz der Message-Klasse, wobei das angegebene Objekt mithilfe des angegebenen Formatierers in den Meldungstext serialisiert wird.Initializes a new instance of the Message class using the specified formatter to serialize the specified object into the body of the message.

Felder

InfiniteTimeout InfiniteTimeout InfiniteTimeout InfiniteTimeout

Gibt an, dass kein Timeout vorhanden ist.Specifies that no time-out exists.

Eigenschaften

AcknowledgeType AcknowledgeType AcknowledgeType AcknowledgeType

Ruft den Typ der Bestätigungsmeldung ab, die an die sendende Anwendung zurückgegeben werden soll, oder legt diesen fest.Gets or sets the type of acknowledgment message to be returned to the sending application.

Acknowledgment Acknowledgment Acknowledgment Acknowledgment

Ruft die Klassifikation für die Bestätigung ab, die diese Meldung darstellt.Gets the classification of acknowledgment that this message represents.

AdministrationQueue AdministrationQueue AdministrationQueue AdministrationQueue

Ruft die Warteschlange ab, die die von Message Queuing erzeugten Bestätigungsmeldungen empfängt, oder legt diese fest.Gets or sets the queue that receives the acknowledgement messages that Message Queuing generates.

AppSpecific AppSpecific AppSpecific AppSpecific

Ruft zusätzliche anwendungsspezifische Daten ab oder legt diese fest.Gets or sets additional, application-specific information.

ArrivedTime ArrivedTime ArrivedTime ArrivedTime

Ruft den Zeitpunkt ab, zu dem die Meldung von der Zielwarteschlange empfangen wurde.Gets the time that the message arrived in the destination queue.

AttachSenderId AttachSenderId AttachSenderId AttachSenderId

Ruft einen Wert ab, der angibt, ob die Sender-ID an die Meldung angehängt werden soll, oder legt diesen fest.Gets or sets a value that indicates whether the sender ID should be attached to the message.

Authenticated Authenticated Authenticated Authenticated

Ruft einen Wert ab, der angibt, ob die Nachricht authentifiziert wurde.Gets a value that indicates whether the message was authenticated.

AuthenticationProviderName AuthenticationProviderName AuthenticationProviderName AuthenticationProviderName

Ruft den Namen des Kryptografieanbieters ab, der zum Generieren der digitalen Signatur für die Meldung verwendet wird.Gets or sets the name of the cryptographic provider used to generate the digital signature of the message.

AuthenticationProviderType AuthenticationProviderType AuthenticationProviderType AuthenticationProviderType

Ruft den Typ des Kryptografieanbieters ab, mit dem die digitale Signatur der Meldung generiert wird, oder legt diesen fest.Gets or sets the type of cryptographic provider used to generate the digital signature of the message.

Body Body Body Body

Ruft den Inhalt der Nachricht ab oder legt diesen fest.Gets or sets the content of the message.

BodyStream BodyStream BodyStream BodyStream

Ruft die Daten im Meldungstext ab oder legt diese fest.Gets or sets the information in the body of the message.

BodyType BodyType BodyType BodyType

Ruft den Typ der im Nachrichtenkörper enthaltenen Daten ab oder legt diesen fest.Gets or sets the type of data that the message body contains.

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

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

(Inherited from Component)
ConnectorType ConnectorType ConnectorType 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.Gets or sets a value that indicates that some message properties typically set by Message Queuing were set by the sending application.

Container Container Container Container

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

(Inherited from Component)
CorrelationId CorrelationId CorrelationId 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.Gets or sets the message identifier used by acknowledgment, report, and response messages to reference the original message.

DesignMode DesignMode DesignMode DesignMode

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

(Inherited from Component)
DestinationQueue DestinationQueue DestinationQueue DestinationQueue

Ruft die für eine Meldung angegebene Zielwarteschlange ab.Gets the intended destination queue for a message.

DestinationSymmetricKey DestinationSymmetricKey DestinationSymmetricKey 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.Gets or sets the symmetric key used to encrypt application-encrypted messages or messages sent to foreign queues.

DigitalSignature DigitalSignature DigitalSignature DigitalSignature

Ruft die digitale Signatur ab, mit der Message Queuing die Meldung authentifiziert, oder legt diese fest.Gets or sets the digital signature that Message Queuing uses to authenticate the message.

EncryptionAlgorithm EncryptionAlgorithm EncryptionAlgorithm EncryptionAlgorithm

Ruft den Verschlüsselungsalgorithmus ab, der zum Verschlüsseln des Meldungstextes einer privaten Meldung verwendet wird, oder legt diesen fest.Gets or sets the encryption algorithm used to encrypt the body of a private message.

Events Events Events Events

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

(Inherited from Component)
Extension Extension Extension Extension

Ruft weitere anwendungsspezifische, der Nachricht zugeordnete Informationen ab oder legt diese fest.Gets or sets additional, application-defined information associated with the message.

Formatter Formatter Formatter Formatter

Ruft den Formatierer ab, der zum Serialisieren und Deserialisieren eines Objekts in bzw. aus dem Nachrichtenkörper verwendet wird.Gets or sets the formatter used to serialize an object into or deserialize an object from the message body.

HashAlgorithm HashAlgorithm HashAlgorithm HashAlgorithm

Ruft den zur Authentifizierung oder zur Erzeugung der digitalen Signatur einer Meldung von Message Queuing verwendeten Hashalgorithmus ab oder legt diesen fest.Gets or sets the hashing algorithm that Message Queuing uses when authenticating a message or creating a digital signature for a message.

Id Id Id Id

Ruft die ID der Nachricht ab.Gets the message's identifier.

IsFirstInTransaction IsFirstInTransaction IsFirstInTransaction IsFirstInTransaction

Ruft einen Wert ab, der angibt, ob die Meldung als erste Meldung in einer Transaktion gesendet wurde.Gets a value that indicates whether the message was the first message sent in a transaction.

IsLastInTransaction IsLastInTransaction IsLastInTransaction IsLastInTransaction

Ruft einen Wert ab, der angibt, ob die Meldung als letzte Meldung in einer Transaktion gesendet wurde.Gets a value that indicates whether the message was the last message sent in a transaction.

Label Label Label Label

Ruft eine von der Anwendung definierte Unicode-Zeichenfolge ab, die die Nachricht beschreibt, oder legt diese fest.Gets or sets an application-defined Unicode string that describes the message.

LookupId LookupId LookupId LookupId

Eingeführt in MSMQ 3.0.Introduced in MSMQ 3.0. Ruft den Suchbezeichner der Meldung ab.Gets the message's lookup identifier.

MessageType MessageType MessageType MessageType

Ruft den Nachrichtentyp ab: Normal, Acknowledgment oder Report.Gets the message type: Normal, Acknowledgment, or Report.

Priority Priority Priority Priority

Ruft die Nachrichtenpriorität ab, die die Position der Nachricht in der Warteschlange bestimmt, oder legt diese fest.Gets or sets the message priority, which determines where in the queue the message is placed.

Recoverable Recoverable Recoverable Recoverable

Ruft einen Wert ab, der angibt, ob die Zustellung einer Meldung im Falle eines Computerfehlers oder Netzwerkproblems sichergestellt ist, oder legt diesen fest.Gets or sets a value that indicates whether the message is guaranteed to be delivered in the event of a computer failure or network problem.

ResponseQueue ResponseQueue ResponseQueue ResponseQueue

Ruft die Warteschlange ab, die von einer Anwendung generierte Antwortnachrichten empfängt, oder legt diese fest.Gets or sets the queue that receives application-generated response messages.

SecurityContext SecurityContext SecurityContext SecurityContext

Ruft den Sicherheitskontext für eine Meldung ab oder legt diesen fest.Gets or sets the security context for a message.

SenderCertificate SenderCertificate SenderCertificate SenderCertificate

Ruft das zum Authentifizieren von Meldungen verwendete Sicherheitszertifikat ab oder legt dieses fest.Gets or sets the security certificate used to authenticate messages.

SenderId SenderId SenderId SenderId

Ruft die ID des sendenden Benutzers ab.Gets the identifier of the sending user.

SenderVersion SenderVersion SenderVersion SenderVersion

Ruft die Version von Message Queuing ab, mit der die Meldung gesendet wurde.Gets the version of Message Queuing used to send the message.

SentTime SentTime SentTime SentTime

Ruft Datum und Uhrzeit auf dem sendenden Computer ab, zu der die Nachricht vom Quellwarteschlangen-Manager gesendet wurde.Gets the date and time on the sending computer that the message was sent by the source queue manager.

Site Site Site Site

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

(Inherited from Component)
SourceMachine SourceMachine SourceMachine SourceMachine

Ruft den Computer ab, von dem die Meldung ausging.Gets the computer from which the message originated.

TimeToBeReceived TimeToBeReceived TimeToBeReceived TimeToBeReceived

Ruft die Zeitbegrenzung für den Empfang der Meldung aus der Zielwarteschlange ab oder legt diese fest.Gets or sets the maximum amount of time for the message to be received from the destination queue.

TimeToReachQueue TimeToReachQueue TimeToReachQueue TimeToReachQueue

Ruft die Zeitbegrenzung der Nachricht für das Erreichen der Warteschlange ab oder legt diese fest.Gets or sets the maximum amount of time for the message to reach the queue.

TransactionId TransactionId TransactionId TransactionId

Ruft die ID der Transaktion ab, in der die Meldung gesendet wurde.Gets the identifier for the transaction of which the message was a part.

TransactionStatusQueue TransactionStatusQueue TransactionStatusQueue TransactionStatusQueue

Ruft die Transaktionsstatus-Warteschlange auf dem Quellcomputer ab.Gets the transaction status queue on the source computer.

UseAuthentication UseAuthentication UseAuthentication UseAuthentication

Ruft einen Wert ab, der angibt, ob die Meldung vor dem Absenden authentifiziert wurde oder authentifiziert werden muss, oder legt diesen fest.Gets or sets a value that indicates whether the message was (or must be) authenticated before being sent.

UseDeadLetterQueue UseDeadLetterQueue UseDeadLetterQueue 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.Gets or sets a value that indicates whether a copy of the message that could not be delivered should be sent to a dead-letter queue.

UseEncryption UseEncryption UseEncryption UseEncryption

Ruft einen Wert ab, der angibt, ob die Meldung als privat behandelt werden soll, oder legt diesen fest.Gets or sets a value that indicates whether to make the message private.

UseJournalQueue UseJournalQueue UseJournalQueue 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.Gets or sets a value that indicates whether a copy of the message should be kept in a machine journal on the originating computer.

UseTracing UseTracing UseTracing UseTracing

Ruft einen Wert ab, der angibt, ob eine Meldung während der Weiterleitung an die Zielwarteschlange verfolgt wird, oder legt diesen fest.Gets or sets a value that indicates whether to trace a message as it moves toward its destination queue.

Methoden

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

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

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()

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

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

Gibt die von Component verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.Releases the unmanaged resources used by the Component and optionally releases the managed resources.

(Inherited from Component)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

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

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

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

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

(Inherited from MarshalByRefObject)
GetService(Type) GetService(Type) GetService(Type) GetService(Type)

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

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

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

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

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

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

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

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

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

(Inherited from MarshalByRefObject)
ToString() ToString() ToString() ToString()

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

(Inherited from Component)

Ereignisse

Disposed Disposed Disposed Disposed

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

(Inherited from Component)

Gilt für:

Siehe auch