Message Classe

Referência

Definição

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Concede acesso às propriedades necessárias para definir uma mensagem de Enfileiramento de Mensagens.

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

public class Message : System.ComponentModel.Component

type Message = class
    inherit Component

Public Class Message
Inherits Component

Herança: Object

MarshalByRefObject

Component
Message

Exemplos

O exemplo de código a seguir demonstra a formatação de um corpo de mensagem usando 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

O exemplo de código a seguir demonstra a formatação de um corpo de mensagem usando 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

Comentários

Use a Message classe para espiar ou receber mensagens de uma fila ou para ter um bom controle sobre as propriedades da mensagem ao enviar uma mensagem para uma fila.

MessageQueue usa a Message classe quando espia ou recebe mensagens de filas, pois os MessageQueue.Peek métodos e MessageQueue.Receive criam uma nova instância da Message classe e definem as propriedades da instância. As Message propriedades somente leitura da classe se aplicam à recuperação de mensagens de uma fila, enquanto as propriedades de leitura/gravação se aplicam ao envio e recuperação de mensagens. Quando MessageQueue espia ou recebe uma mensagem de uma fila, sua MessageReadPropertyFilter propriedade determina quais das propriedades da mensagem são recuperadas.

O MessageQueue método da Send classe permite que você especifique qualquer tipo de objeto para uma mensagem que está sendo enviada para essa fila. Você pode usar a MessageQueue propriedade da DefaultPropertiesToSend instância para especificar configurações para mensagens genéricas enviadas para a fila. Os tipos de configurações incluem formatador, rótulo, criptografia e autenticação. Você também pode especificar valores para os membros apropriados DefaultPropertiesToSend ao coordenar seu aplicativo de mensagens para responder a mensagens de reconhecimento e relatório. Usar uma Message instância para enviar uma mensagem para a fila oferece a flexibilidade de acessar e modificar muitas dessas propriedades , seja para uma única mensagem ou em uma base de mensagem por mensagem. Message as propriedades têm precedência sobre DefaultPropertiesToSend.

Os dados da mensagem são armazenados na Body propriedade e, em menor grau, nas AppSpecific propriedades e Extension . Quando os dados da mensagem são criptografados, serializados ou desserializados, somente o conteúdo da Body propriedade é afetado.

O conteúdo da Body propriedade é serializado quando a mensagem é enviada, usando a Formatter propriedade especificada. O conteúdo serializado é encontrado na BodyStream propriedade . Você também pode definir a BodyStream propriedade diretamente, por exemplo, para enviar um arquivo como o conteúdo de dados de uma mensagem. Você pode alterar as propriedades ou Formatter a Body qualquer momento antes de enviar a mensagem e os dados serão serializados adequadamente quando você chamar Send.

As propriedades definidas pela MessageQueue.DefaultPropertiesToSend propriedade se aplicam apenas a mensagens que não são do tipo Message. Se você especificar a DefaultPropertiesToSend propriedade para um MessageQueue, as propriedades nomeadas de forma idêntica em uma Message instância enviada para essa fila farão com que essas propriedades padrão sejam ignoradas.

Para obter uma lista de valores de propriedade iniciais de uma instância do Message, consulte o Message construtor.

Construtores

Message()	Inicializa uma nova instância da classe Message com um corpo vazio.
Message(Object)	Inicializa uma nova instância da classe Message usando o XmlMessageFormatter para serializar o objeto especificado no corpo da mensagem.
Message(Object, IMessageFormatter)	Inicializa uma nova instância da classe Message usando o formatador especificado para serializar o objeto especificado no corpo da mensagem.

Campos

InfiniteTimeout

Especifica que não existe tempo limite.

Propriedades

AcknowledgeType	Obtém ou define o tipo de mensagem de confirmação a ser retornada para o aplicativo de envio.
Acknowledgment	Obtém a classificação da confirmação que esta mensagem representa.
AdministrationQueue	Obtém ou define a fila que recebe as mensagens de confirmação que o Enfileiramento de Mensagens gera.
AppSpecific	Obtém ou define informações adicionais específicas do aplicativo.
ArrivedTime	Obtém a hora em que a mensagem chegou na fila de destino.
AttachSenderId	Obtém ou define um valor que indica se a ID do remetente deve ser anexada à mensagem.
Authenticated	Obtém um valor que indica se a mensagem foi autenticada.
AuthenticationProviderName	Obtém ou define o nome do provedor criptográfico usado para gerar a assinatura digital da mensagem.
AuthenticationProviderType	Obtém ou define o tipo de provedor de criptografia usado para gerar a assinatura digital da mensagem.
Body	Obtém ou define o conteúdo da mensagem.
BodyStream	Obtém ou define as informações no corpo da mensagem.
BodyType	Obtém ou define o tipo de dados que o corpo da mensagem contém.
CanRaiseEvents	Obtém um valor que indica se o componente pode acionar um evento. (Herdado de Component)
ConnectorType	Obtém ou define um valor que indica se algumas propriedades de mensagem geralmente definidas pelo Enfileiramento de Mensagens foram definidas pelo aplicativo de envio.
Container	Obtém o IContainer que contém o Component. (Herdado de Component)
CorrelationId	Obtém ou define o identificador de mensagem usado por mensagens de confirmação, relatório e resposta para fazer referência à mensagem original.
DesignMode	Obtém um valor que indica se o Component está no modo de design no momento. (Herdado de Component)
DestinationQueue	Obtém a fila de destino pretendida para uma mensagem.
DestinationSymmetricKey	Obtém ou define a chave simétrica usada para criptografar mensagens criptografadas por aplicativos ou mensagens enviadas para filas externas.
DigitalSignature	Obtém ou define a assinatura digital que o Enfileiramento de Mensagens usa ao autenticar a mensagem.
EncryptionAlgorithm	Obtém ou define o algoritmo de criptografia usado para criptografar o corpo de uma mensagem privada.
Events	Obtém a lista de manipuladores de eventos que estão anexados a este Component. (Herdado de Component)
Extension	Obtém ou define informações adicionais definidas pelo aplicativo associadas à mensagem.
Formatter	Obtém ou define o formatador usado para serializar ou desserializar um objeto do corpo da mensagem.
HashAlgorithm	Obtém ou define o algoritmo de hash que o Enfileiramento de Mensagens usa ao autenticar uma mensagem ou criar uma assinatura digital para uma mensagem.
Id	Obtém o identificador da mensagem.
IsFirstInTransaction	Obtém um valor que indica se a mensagem foi a primeira mensagem enviada em uma transação.
IsLastInTransaction	Obtém um valor que indica se a mensagem foi a última mensagem enviada em uma transação.
Label	Obtém ou define uma cadeia de caracteres Unicode definida pelo aplicativo que descreve a mensagem.
LookupId	Introduzido no MSMQ 3.0. Obtém o identificador de pesquisa da mensagem.
MessageType	Obtém o tipo de mensagem: `Normal`, `Acknowledgment` ou `Report`.
Priority	Obtém ou define a prioridade da mensagem, que determina o local na fila em que a mensagem foi colocada.
Recoverable	Obtém ou define um valor que indica se há garantia de que a mensagem seja entregue no caso de um problema de rede ou falha do computador.
ResponseQueue	Obtém ou define a fila que recebe mensagens de resposta geradas por aplicativo.
SecurityContext	Obtém ou define o contexto de segurança para uma mensagem.
SenderCertificate	Obtém ou define o certificado de segurança usado para autenticar mensagens.
SenderId	Obtém o identificador do usuário remetente.
SenderVersion	Obtém a versão do Enfileiramento de Mensagens usado para enviar a mensagem.
SentTime	Obtém a data e a hora no computador de envio em que a mensagem foi enviada pelo gerenciador de fila de origem.
Site	Obtém ou define o ISite do Component. (Herdado de Component)
SourceMachine	Obtém o computador que originou a mensagem.
TimeToBeReceived	Obtém ou define a quantidade máxima de tempo para a mensagem a ser recebida da fila de destino.
TimeToReachQueue	Obtém ou define a quantidade máxima de tempo para a mensagem chegar à fila.
TransactionId	Obtém o identificador para a transação da qual a mensagem fazia parte.
TransactionStatusQueue	Obtém a fila de status de transação no computador de origem.
UseAuthentication	Obtém ou define um valor que indica se a mensagem foi (ou deve ser) autenticada antes de ser enviada.
UseDeadLetterQueue	Obtém ou define um valor que indica se uma cópia da mensagem que não pôde ser entregue deve ser enviada a uma fila de mensagens mortas.
UseEncryption	Obtém ou define um valor que indica se a mensagem deve ser tornada privada.
UseJournalQueue	Obtém ou define um valor que indica se uma cópia da mensagem deve ser mantida em um diário de computador no computador de origem.
UseTracing	Obtém ou define um valor que indica se uma mensagem deve ser rastreada enquanto ela se aproxima da sua fila de destino.

Métodos

CreateObjRef(Type)	Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto. (Herdado de MarshalByRefObject)
Dispose()	Libera todos os recursos usados pelo Component. (Herdado de Component)
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo Component e opcionalmente libera os recursos gerenciados. (Herdado de Component)
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetLifetimeService()	Obsoleto. Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância. (Herdado de MarshalByRefObject)
GetService(Type)	Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container. (Herdado de Component)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
InitializeLifetimeService()	Obsoleto. Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
MemberwiseClone(Boolean)	Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject)
ToString()	Retorna um String que contém o nome do Component, se houver. Esse método não deve ser substituído. (Herdado de Component)

Eventos

Disposed

Ocorre quando o componente é disposto por uma chamada ao método Dispose().

(Herdado de Component)

Aplica-se a

Partilhar via