Export (0) Print
Expand All

Message.Body Property

Gets or sets the content of the message.

[Visual Basic]
Public Property Body As Object
[C#]
public object Body {get; set;}
[C++]
public: __property Object* get_Body();
public: __property void set_Body(Object*);
[JScript]
public function get Body() : Object;
public function set Body(Object);

Property Value

An object that specifies the message contents. The object can be a string, a date, a currency, a number, an array of bytes, or any managed object.

Exceptions

Exception Type Condition
InvalidOperationException The Formatter property is a null reference (Nothing in Visual Basic).

-or-

The message queue is filtered to ignore the Body property.

Remarks

The message's Body property usually contains the data associated with the message. 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. Only the Body property contents are serialized or encrypted.

The Body property can contain any object whose size does not exceed 4 MB. 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.

Note   The string argument in MessageQueue.Send("hello.") is an example of such a generic object.

The BodyType property indicates the type of information that is stored in the message body. Message Queuing uses this information to identify the type of the Body property contents.

Specify either the Body property or the BodyStream property before sending the Message object. The Body property can be any serializable object, such as a text string, structure object, class instance, or embedded object.

Unless you write the contents of the message directly to the BodyStream property, set the Formatter property before you send the message. When the Send method is called on the MessageQueue instance, the body is serialized using the formatter contained in the Formatter property. If you send the message without specifying a value for the Formatter property, the formatter defaults to XmlMessageFormatter.

Example

[Visual Basic, C#, C++] The following example sends 2 messages of different priorities to the queue, and retrieves them subsequently.

[Visual Basic] 
Imports System
Imports 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 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 'Main
      
      
      
      '**************************************************
      ' 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 'SendMessage
      
      
      
      '**************************************************
      ' 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()))
         
         Catch
         ' Handle Message Queuing exceptions.
         
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         End Try
         
         ' Catch other exceptions as necessary.
         Return
      End Sub 'ReceiveMessage
   End Class 'MyNewQueue
End Namespace 'MyProject

[C#] 
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;
        }
    }
}

[C++] 
#using <mscorlib.dll>
#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

__gc class MyNewQueue 
{
public:
    void SendMessage(MessagePriority priority, String* messageBody) 
    {

        // Connect to a queue on the local computer.
        MessageQueue* myQueue = new MessageQueue(S".\\myQueue");

        // Create a new message.
        Message* myMessage = new Message();

        if (priority > MessagePriority::Normal) 
        {
            myMessage->Body = S"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;
    }

public:
    void ReceiveMessage() 
    {
        // Connect to the a queue on the local computer.
        MessageQueue* myQueue = new MessageQueue(S".\\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*.
        Type* p __gc[] = new Type* __gc[1];
        p[0] = __typeof(String);
        myQueue->Formatter = new XmlMessageFormatter( p );

        try 
        {
            // Receive and format the message. 
            Message* myMessage = myQueue->Receive(); 

            // Display message information.
            Console::WriteLine(S"Priority: {0}", __box(myMessage->Priority));
            Console::WriteLine(S"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;
    }
};

int main() 
{
    // Create a new instance of the class.
    MyNewQueue* myNewQueue = new MyNewQueue();

    // Send messages to a queue.
    myNewQueue->SendMessage(MessagePriority::Normal, S"First Message Body.");
    myNewQueue->SendMessage(MessagePriority::Highest, S"Second Message Body.");

    // Receive messages from a queue.
    myNewQueue->ReceiveMessage(); 
    myNewQueue->ReceiveMessage();

    return 0;

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

.NET Framework Security: 

See Also

Message Class | Message Members | System.Messaging Namespace | Message | BodyStream | BodyType | Formatter | AppSpecific | Extension | UseEncryption | Send

Show:
© 2014 Microsoft