Message Clase

Referencia

Definición

Espacio de nombres:: System.Messaging

Ensamblado:: System.Messaging.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Proporciona acceso a las propiedades necesarias para definir un mensaje de Message Queuing.

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

public class Message : System.ComponentModel.Component

type Message = class
    inherit Component

Public Class Message
Inherits Component

Herencia: Object

MarshalByRefObject

Component
Message

Ejemplos

En el ejemplo de código siguiente se muestra cómo aplicar formato a un cuerpo del mensaje mediante BinaryMessageFormatter.

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

En el ejemplo de código siguiente se muestra cómo aplicar formato a un cuerpo del mensaje mediante 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

Comentarios

Use la Message clase para ver o recibir mensajes de una cola, o para tener un control preciso sobre las propiedades del mensaje al enviar un mensaje a una cola.

MessageQueue usa la Message clase cuando busca o recibe mensajes de las colas, ya que los MessageQueue.Peek métodos y MessageQueue.Receive crean una nueva instancia de la Message clase y establecen las propiedades de la instancia. Las Message propiedades de solo lectura de la clase se aplican a la recuperación de mensajes de una cola, mientras que las propiedades de lectura y escritura se aplican al envío y recuperación de mensajes. Cuando MessageQueue busca o recibe un mensaje de una cola, su MessageReadPropertyFilter propiedad determina cuáles de las propiedades del mensaje se recuperan.

El método de la MessageQueue Send clase permite especificar cualquier tipo de objeto para un mensaje que se envía a esa cola. Puede usar la propiedad de DefaultPropertiesToSend la MessageQueue instancia para especificar la configuración de los mensajes genéricos enviados a la cola. Los tipos de configuración incluyen formateador, etiqueta, cifrado y autenticación. También puede especificar valores para los miembros adecuados DefaultPropertiesToSend al coordinar la aplicación de mensajería para responder a mensajes de confirmación e informe. El uso de una Message instancia de para enviar un mensaje a la cola ofrece la flexibilidad de acceder y modificar muchas de estas propiedades, ya sea para un solo mensaje o por mensaje. Message las propiedades tienen prioridad sobre DefaultPropertiesToSend.

Los datos del mensaje se almacenan en la Body propiedad y, en menor medida, las AppSpecific propiedades y Extension . Cuando los datos del mensaje se cifran, serializan o deserializan, solo se ven afectados el contenido de la Body propiedad.

El contenido de la Body propiedad se serializa cuando se envía el mensaje, utilizando la Formatter propiedad especificada. El contenido serializado se encuentra en la BodyStream propiedad . También puede establecer la BodyStream propiedad directamente, por ejemplo, para enviar un archivo como contenido de datos de un mensaje. Puede cambiar las Body propiedades o Formatter en cualquier momento antes de enviar el mensaje y los datos se serializarán correctamente al llamar a Send.

Las propiedades definidas por la MessageQueue.DefaultPropertiesToSend propiedad solo se aplican a los mensajes que no son de tipo Message. Si especifica la DefaultPropertiesToSend propiedad para , MessageQueuelas propiedades con nombre idéntico de una Message instancia enviada a esa cola hacen que se omitan estas propiedades predeterminadas.

Para obtener una lista de valores de propiedad iniciales para una instancia de Message, vea el Message constructor .

Constructores

Message()	Inicializa una nueva instancia de la clase Message con un cuerpo de mensaje vacío.
Message(Object)	Inicializa una nueva instancia de la clase Message, utilizando XmlMessageFormatter para serializar el objeto especificado en el cuerpo del mensaje.
Message(Object, IMessageFormatter)	Inicializa una instancia nueva de la clase Message, utilizando el formateador especificado para serializar el objeto especificado en el cuerpo del mensaje.

Campos

InfiniteTimeout

Especifica que no existe un tiempo de espera.

Propiedades

AcknowledgeType	Obtiene o establece el tipo de mensaje de confirmación que debe devolverse a la aplicación que hace el envío.
Acknowledgment	Obtiene la clasificación de confirmación que representa este mensaje.
AdministrationQueue	Obtiene o establece la cola utilizada para los mensajes de confirmación generados por Message Queuing.
AppSpecific	Obtiene o establece información adicional específica de la aplicación.
ArrivedTime	Obtiene la hora en que llegó el mensaje a la cola de destino.
AttachSenderId	Obtiene o establece un valor que indica si se adjuntará al mensaje el identificador del remitente.
Authenticated	Obtiene un valor que indica si se autenticó el mensaje.
AuthenticationProviderName	Obtiene o establece el nombre del proveedor criptográfico que se utiliza para generar la firma digital del mensaje.
AuthenticationProviderType	Obtiene o establece el tipo del proveedor criptográfico que se utiliza para generar la firma digital del mensaje.
Body	Obtiene o establece el contenido del mensaje.
BodyStream	Obtiene o establece la información del cuerpo del mensaje.
BodyType	Obtiene o establece el tipo de datos que contiene el cuerpo del mensaje.
CanRaiseEvents	Obtiene un valor que indica si el componente puede generar un evento. (Heredado de Component)
ConnectorType	Obtiene y establece un valor que indica que la aplicación de envío estableció algunas propiedades de mensajes, normalmente establecidas por Message Queuing.
Container	Obtiene la interfaz IContainer que contiene la clase Component. (Heredado de Component)
CorrelationId	Obtiene o establece el identificador de mensaje que utilizan los mensajes de confirmación, informe y respuesta para hacer referencia al mensaje original.
DesignMode	Obtiene un valor que indica si Component está actualmente en modo de diseño. (Heredado de Component)
DestinationQueue	Obtiene la cola de destino deseada para un mensaje.
DestinationSymmetricKey	Obtiene o establece la clave simétrica utilizada para cifrar los mensajes cifrados por la aplicación o los enviados a colas externas.
DigitalSignature	Obtiene o establece la firma digital que Message Queuing utiliza para autenticar el mensaje.
EncryptionAlgorithm	Obtiene o establece el algoritmo de cifrado que se utiliza para cifrar el cuerpo de un mensaje privado.
Events	Obtiene la lista de controladores de eventos asociados a Component. (Heredado de Component)
Extension	Obtiene o establece información adicional, definida por la aplicación y asociada al mensaje.
Formatter	Obtiene o establece el formateador empleado para serializar o deserializar un objeto en el cuerpo de un mensaje.
HashAlgorithm	Obtiene o establece el algoritmo de hash que Message Queuing utiliza al autenticar mensajes o al crear una firma digital para un mensaje.
Id	Obtiene el identificador del mensaje.
IsFirstInTransaction	Obtiene un valor que indica si el mensaje era el primer mensaje enviado en una transacción.
IsLastInTransaction	Obtiene un valor que indica si el mensaje era el último mensaje enviado en una transacción.
Label	Obtiene o establece una cadena Unicode definida por la aplicación que describe el mensaje.
LookupId	Introducido en MSMQ 3.0. Obtiene el identificador de búsqueda del mensaje.
MessageType	Obtiene el tipo de mensaje: `Normal`, `Acknowledgment` o `Report`.
Priority	Obtiene o establece la prioridad del mensaje, que determina en qué punto de la cola se ubica el mensaje.
Recoverable	Obtiene o establece un valor que indica si se garantiza la entrega del mensaje en caso de haber errores en el equipo o problemas en la red.
ResponseQueue	Obtiene o establece la cola que recibe los mensajes de respuesta generados por la aplicación.
SecurityContext	Obtiene o establece el contexto de seguridad para un mensaje.
SenderCertificate	Obtiene o establece el certificado de seguridad que se utilizará para autenticar mensajes.
SenderId	Obtiene el identificador del usuario remitente.
SenderVersion	Obtiene la versión de Message Queuing que se utilizó para enviar el mensaje.
SentTime	Obtiene la fecha y hora del equipo de envío en las que el administrador de colas de origen envió el mensaje.
Site	Obtiene o establece ISite de Component. (Heredado de Component)
SourceMachine	Obtiene el equipo donde se originó el mensaje.
TimeToBeReceived	Obtiene o establece el límite máximo de tiempo para recibir el mensaje de la cola de destino.
TimeToReachQueue	Obtiene o establece el límite máximo de tiempo para que el mensaje alcance la cola.
TransactionId	Obtiene el identificador de la transacción a la que pertenecía el mensaje.
TransactionStatusQueue	Obtiene la cola de estado de transacción del equipo de origen.
UseAuthentication	Obtiene o establece un valor que indica si se autenticó (o debe autenticarse) el mensaje antes de enviarse.
UseDeadLetterQueue	Obtiene o establece un valor que indica si debe enviarse una copia del mensaje que no pudo entregarse a la cola de mensajes no enviados.
UseEncryption	Obtiene o establece un valor que indica si el mensaje debe ser privado.
UseJournalQueue	Obtiene o establece un valor que indica si debe conservarse una copia del mensaje en un diario del equipo de origen.
UseTracing	Obtiene o establece un valor que indica si se debe seguir la traza de un mensaje mientras se traslada a su cola de destino.

Métodos

CreateObjRef(Type)	Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
Dispose()	Libera todos los recursos que usa Component. (Heredado de Component)
Dispose(Boolean)	Libera los recursos no administrados que usa Component y, de forma opcional, libera los recursos administrados. (Heredado de Component)
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetLifetimeService()	Obsoletos. Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
GetService(Type)	Devuelve un objeto que representa el servicio suministrado por Component o por Container. (Heredado de Component)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
InitializeLifetimeService()	Obsoletos. Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject)
ToString()	Devuelve una String que contiene el nombre del Component, si existe. Este método no se debe invalidar. (Heredado de Component)

Eventos

Disposed

Tiene lugar cuando una llamada elimina el componente mediante una llamada al método Dispose().

(Heredado de Component)

Se aplica a

Compartir a través de