Message.Body Eigenschaft

Definition

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

public:
 property System::Object ^ Body { System::Object ^ get(); void set(System::Object ^ value); };
[System.ComponentModel.Browsable(false)]
public object Body { get; set; }
member this.Body : obj with get, set
Public Property Body As Object

Eigenschaftswert

Ein Objekt, das den Inhalt der Meldung enthält.An object that specifies the message contents. Das Objekt kann eine Zeichenfolge, ein Datum, eine Währung, eine Zahl, ein Bytearray oder ein beliebiges verwaltetes Objekt sein.The object can be a string, a date, a currency, a number, an array of bytes, or any managed object.

Attribute

Ausnahmen

Die Formatter-Eigenschaft ist null.The Formatter property is null.

- oder --or- Die Body-Eigenschaft wird aufgrund eines für die Meldungswarteschlange gesetzten Filters ignoriert.The message queue is filtered to ignore the Body property.

Beispiele

Im folgenden Codebeispiel werden zwei Nachrichten mit unterschiedlichen Prioritäten an die Warteschlange gesendet und anschließend abgerufen.The following code example sends two messages of different priorities to the queue, and retrieves them subsequently.


#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

Die- Body Eigenschaft der Meldung enthält normalerweise die Daten, die der Nachricht zugeordnet sind.The message's Body property usually contains the data associated with the message. Obwohl Sie auch anwendungsspezifische Daten in den AppSpecific Eigenschaften und Extension senden können, sollten Sie nach Möglichkeit Nachrichten Daten in den Body der Nachricht einschließen.Although you can also send application-specific data in the AppSpecific and Extension properties, you should include message data in the Body of the message whenever possible. Nur der Body Eigenschafts Inhalt wird serialisiert oder verschlüsselt.Only the Body property contents are serialized or encrypted.

Die Body -Eigenschaft kann ein beliebiges-Objekt enthalten, dessen Größe 4 MB nicht überschreitet.The Body property can contain any object whose size does not exceed 4 MB. Wenn Sie verwenden MessageQueue.Send , um ein Objekt zu senden, das nicht Message vom Typ MessageQueueist, wird dieses Objekt in der Body -Eigenschaft der- Message Instanz, die Peek von Receiveoder zurückgegeben wird, gefunden.If you use MessageQueue.Send to send any object that is not of type Message to the MessageQueue, that object will be located in the Body property of the Message instance returned by Peek or Receive.

Das Zeichen folgen Argument MessageQueue.Send("hello.") in ist ein Beispiel für ein solches generisches Objekt.The string argument in MessageQueue.Send("hello.") is an example of such a generic object.

Die BodyType -Eigenschaft gibt den Typ der Informationen an, die im Nachrichtentext gespeichert sind.The BodyType property indicates the type of information that is stored in the message body. Message Queuing verwendet diese Informationen, um den Typ des Body Eigenschafts Inhalts zu identifizieren.Message Queuing uses this information to identify the type of the Body property contents.

Geben Sie vor Body dem Senden des BodyStream Message Objekts entweder die-Eigenschaft oder die-Eigenschaft an.Specify either the Body property or the BodyStream property before sending the Message object. Die Body Eigenschaft kann ein beliebiges serialisierbares Objekt sein, z. b. eine Text Zeichenfolge, ein Struktur Objekt, eine Klasseninstanz oder ein eingebettetes ObjektThe Body property can be any serializable object, such as a text string, structure object, class instance, or embedded object.

Wenn Sie den Inhalt der Nachricht nicht direkt in die BodyStream -Eigenschaft schreiben, legen Sie die Formatter -Eigenschaft vor dem Senden der Nachricht fest.Unless you write the contents of the message directly to the BodyStream property, set the Formatter property before you send the message. Wenn die Send -Methode für die MessageQueue -Instanz aufgerufen wird, wird der Text mit dem Formatierer serialisiert, Formatter der in der-Eigenschaft enthalten ist.When the Send method is called on the MessageQueue instance, the body is serialized using the formatter contained in the Formatter property. Wenn Sie die Nachricht senden, ohne einen Wert für die Formatter -Eigenschaft anzugeben, ist der Formatierer standardmäßig auf XmlMessageFormatterfestgelegt.If you send the message without specifying a value for the Formatter property, the formatter defaults to XmlMessageFormatter.

Hinweis

MaxValue OverflowException Send WennSieActiveXMessageFormatter versuchen, den Text einer Nachricht auf festzulegen, wird eine ausgelöst, wenn die-Methode der- Klasseaufgerufenwirdundverwendetwird.MessageQueueAttempting to set the body of a message to MaxValue will cause a OverflowException when the Send method of the MessageQueue class is called and the ActiveXMessageFormatter is used.

Gilt für:

Siehe auch