Partilhar via


Message Classe

Definição

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

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

Confira também