Message.Body Propiedad

Definición

Obtiene o establece el contenido del mensaje.

[System.ComponentModel.Browsable(false)]
public object Body { get; set; }

Valor de propiedad

Objeto que especifica el contenido del mensaje. El objeto puede ser una cadena, una fecha, una divisa, un número, una matriz de bytes o cualquier objeto administrado.

Atributos

Excepciones

La propiedad Formatter es null.

o bien

La cola de mensajes se filtra para omitir la propiedad Body.

Ejemplos

En el ejemplo de código siguiente se envían dos mensajes de prioridades diferentes a la cola y se recuperan posteriormente.

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;
        }
    }
}

Comentarios

La propiedad del Body mensaje normalmente contiene los datos asociados al mensaje. Aunque también puede enviar datos específicos de la aplicación en las AppSpecific propiedades y Extension , debe incluir los datos del mensaje en del Body mensaje siempre que sea posible. Solo el contenido de la Body propiedad se serializa o cifra.

La Body propiedad puede contener cualquier objeto cuyo tamaño no supere los 4 MB. Si usa MessageQueue.Send para enviar cualquier objeto que no sea de tipo Message a MessageQueue, ese objeto se ubicará en la Body propiedad de la Message instancia devuelta por Peek o Receive.

El argumento string de MessageQueue.Send("hello.") es un ejemplo de este objeto genérico.

La BodyType propiedad indica el tipo de información que se almacena en el cuerpo del mensaje. Message Queuing usa esta información para identificar el tipo del contenido de la Body propiedad.

Especifique la Body propiedad o la BodyStream propiedad antes de enviar el Message objeto. La Body propiedad puede ser cualquier objeto serializable, como una cadena de texto, un objeto de estructura, una instancia de clase o un objeto incrustado.

A menos que escriba el contenido del mensaje directamente en la BodyStream propiedad , establezca la Formatter propiedad antes de enviar el mensaje. Cuando se llama al Send método en la MessageQueue instancia de , el cuerpo se serializa mediante el formateador contenido en la Formatter propiedad . Si envía el mensaje sin especificar un valor para la Formatter propiedad , el formateador tiene como valor predeterminado XmlMessageFormatter.

Nota

Si se intenta establecer el cuerpo de un mensaje en MaxValue , se producirá una OverflowException excepción cuando se llame al Send método de la MessageQueue clase y ActiveXMessageFormatter se use .

Se aplica a

Producto Versiones
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1

Consulte también