XmlMessageFormatter 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.

Serializa e desserializa objetos para ou do corpo de uma mensagem, usando o formato XML baseado na definição de esquema XSD.

public ref class XmlMessageFormatter : ICloneable, System::Messaging::IMessageFormatter

public class XmlMessageFormatter : ICloneable, System.Messaging.IMessageFormatter

type XmlMessageFormatter = class
    interface IMessageFormatter
    interface ICloneable

Public Class XmlMessageFormatter
Implements ICloneable, IMessageFormatter

Herança: Object
XmlMessageFormatter

Implementações: ICloneable IMessageFormatter

Exemplos

O exemplo de código a seguir inclui três partes de código: um componente de servidor, uma classe de pedido e um código do cliente. A classe order pode ser usada pelo utilitário XSD.exe para gerar o esquema que o servidor reconhece em mensagens de entrada. O esquema é um arquivo formatado em XML que descreve a "forma" da classe . Esse esquema pode então ser usado no lado do cliente para gerar uma classe de pedido específica do cliente que compartilha o mesmo esquema que a classe de servidor.

O exemplo de código a seguir representa um componente de servidor que recebe pedidos por meio de uma fila de mensagens. O corpo da mensagem deve ser um objeto de ordem cujo esquema corresponde à classe Order.cs abaixo. O processo do servidor ou aplicativo desserializa a ordem.

#using <System.dll>
#using <System.Messaging.dll>

using namespace System;
using namespace System::Messaging;

// placeholder; see complete definition elsewhere in this section
public ref class Order
{
public:
   void ShipItems(){}

};


// Creates the queue if it does not already exist.
void EnsureQueueExists( String^ path )
{
   if (  !MessageQueue::Exists( path ) )
   {
      MessageQueue::Create( path );
   }
}

int main()
{
   Console::WriteLine( "Processing Orders" );
   String^ queuePath = ".\\orders";
   EnsureQueueExists( queuePath );
   MessageQueue^ queue = gcnew MessageQueue( queuePath );
   array<String^>^temp0 = {"Order"};
   (dynamic_cast<XmlMessageFormatter^>(queue->Formatter))->TargetTypeNames = temp0;
   while ( true )
   {
      Order^ newOrder = dynamic_cast<Order^>(queue->Receive()->Body);
      newOrder->ShipItems();
   }
}

using System;
using System.Messaging;

 public class Server{

     public static void Main(){

         Console.WriteLine("Processing Orders");

         string queuePath = ".\\orders";
         EnsureQueueExists(queuePath);
         MessageQueue queue = new MessageQueue(queuePath);
         ((XmlMessageFormatter)queue.Formatter).TargetTypeNames = new string[]{"Order"};

         while(true){
             Order newOrder = (Order)queue.Receive().Body;
             newOrder.ShipItems();
         }
     }

     // Creates the queue if it does not already exist.
     public static void EnsureQueueExists(string path){
         if(!MessageQueue.Exists(path)){
             MessageQueue.Create(path);
         }
     }
 }

Imports System.Messaging



Public Class Server
    
    
    Public Shared Sub Main()
        
        Console.WriteLine("Processing Orders")
        
        Dim queuePath As String = ".\orders"
        EnsureQueueExists(queuePath)
        Dim queue As New MessageQueue(queuePath)
        CType(queue.Formatter, XmlMessageFormatter).TargetTypeNames = New String() {"Order"}
        
        While True
            Dim newOrder As Order = CType(queue.Receive().Body, Order)
            newOrder.ShipItems()
        End While
    End Sub
    
    
    ' Creates the queue if it does not already exist.
    Public Shared Sub EnsureQueueExists(path As String)
        If Not MessageQueue.Exists(path) Then
            MessageQueue.Create(path)
        End If
    End Sub
End Class

O exemplo de código a seguir representa a classe de pedido que fornece um esquema para os objetos de ordem que o aplicativo no servidor recebe e desserializa.

using namespace System;
public ref class Order
{
public:
   int itemId;
   int quantity;
   String^ address;
   void ShipItems()
   {
      Console::WriteLine( "Order Placed:" );
      Console::WriteLine( "\tItem ID  : {0}", itemId );
      Console::WriteLine( "\tQuantity : {0}", quantity );
      Console::WriteLine( "\tShip To  : {0}", address );
      
      // Add order to the database.
      /* Insert code here. */
   }

};

using System;

 public class Order{

     public int itemId;
     public int quantity;
     public string address;

     public void ShipItems(){

         Console.WriteLine("Order Placed:");
         Console.WriteLine("\tItem ID  : {0}",itemId);
         Console.WriteLine("\tQuantity : {0}",quantity);
         Console.WriteLine("\tShip To  : {0}",address);

         // Add order to the database.
         /* Insert code here. */
     }
 }

Public Class Order
    
    Public itemId As Integer
    Public quantity As Integer
    Public address As String
    
    
    Public Sub ShipItems()
        
        Console.WriteLine("Order Placed:")
        Console.WriteLine(ControlChars.Tab & "Item ID  : {0}", itemId)
        Console.WriteLine(ControlChars.Tab & "Quantity : {0}", quantity)
        Console.WriteLine(ControlChars.Tab & "Ship To  : {0}", address)

        ' Add order to the database.
        ' Insert code here.
 
    End Sub
End Class

Qualquer aplicativo cliente que interage com o aplicativo no servidor deve enviar mensagens para o servidor serializando informações em uma classe de ordem definida localmente no corpo da mensagem. A classe de ordem definida localmente deve ter o mesmo esquema que a classe de ordem definida pelo servidor na qual o aplicativo no servidor tentará desserializar o corpo da mensagem. O utilitário XSD.exe permite que o gerente do aplicativo no servidor crie e distribua o esquema que o cliente deve usar para serializar mensagens que vão para o servidor.

Quando o gerente do aplicativo cliente recebe o esquema da classe de pedido, o utilitário XSD.exe é usado novamente para gerar uma classe de pedido específica do cliente do esquema. É essa classe usada no exemplo de código do cliente abaixo, não a classe de pedido do servidor (o utilitário XSD.exe faz com que a classe gerada por esquema tenha o mesmo nome que a classe original). Essa nova classe de pedido é usada para serializar a ordem no corpo da mensagem.

O exemplo de código a seguir é o processamento do lado do cliente, usado para serializar um pedido e enviar as informações associadas ao pedido para uma fila. O código associa informações de Item, Quantidade e Endereço a elementos do esquema que foram gerados para a classe Order.cs pelo utilitário XSD.exe. Um pedido é enviado para a fila Pedidos no computador local.

#using <System.dll>
#using <System.Messaging.dll>

using namespace System;
using namespace System::Messaging;

// placeholder; see complete definition elsewhere in this section
public ref class Order
{
public:
   int itemId;
   int quantity;
   String^ address;
   void ShipItems(){}

};


// Creates the queue if it does not already exist.
void EnsureQueueExists( String^ path )
{
   if (  !MessageQueue::Exists( path ) )
   {
      MessageQueue::Create( path );
   }
}

int main()
{
   String^ queuePath = ".\\orders";
   EnsureQueueExists( queuePath );
   MessageQueue^ queue = gcnew MessageQueue( queuePath );
   Order^ orderRequest = gcnew Order;
   orderRequest->itemId = 1025;
   orderRequest->quantity = 5;
   orderRequest->address = "One Microsoft Way";
   queue->Send( orderRequest );
   
   // This line uses a new method you define on the Order class:
   // orderRequest.PrintReceipt();
}

using System;
using System.Messaging;

 class Client{

     public static void Main(){

         string queuePath = ".\\orders";
         EnsureQueueExists(queuePath);
         MessageQueue queue = new MessageQueue(queuePath);

         Order orderRequest = new Order();
         orderRequest.itemId = 1025;
         orderRequest.quantity = 5;
         orderRequest.address = "One Microsoft Way";

         queue.Send(orderRequest);
         // This line uses a new method you define on the Order class:
         // orderRequest.PrintReceipt();
     }

     // Creates the queue if it does not already exist.
     public static void EnsureQueueExists(string path){
         if(!MessageQueue.Exists(path)){
             MessageQueue.Create(path);
         }
     }
 }

Imports System.Messaging

Class Client
    
    
    Public Shared Sub Main()
        
        Dim queuePath As String = ".\orders"
        EnsureQueueExists(queuePath)
        Dim queue As New MessageQueue(queuePath)
        
        Dim orderRequest As New Order()
        orderRequest.itemId = 1025
        orderRequest.quantity = 5
        orderRequest.address = "One Microsoft Way"
        
        queue.Send(orderRequest)
        ' This line uses a new method you define on the Order class:
        ' orderRequest.PrintReceipt()

    End Sub
    
    ' Creates the queue if it does not already exist.
    Public Shared Sub EnsureQueueExists(path As String)
        If Not MessageQueue.Exists(path) Then
            MessageQueue.Create(path)
        End If
    End Sub
End Class

Depois que o esquema for gerado a partir da classe de pedido no servidor, você poderá modificar a classe . A menos que o esquema seja alterado, você não precisará redistribuir o esquema. Depois de distribuir o esquema e gerar uma classe de pedido do lado do cliente, essa classe de cliente também pode ser modificada independentemente da classe de pedido do servidor, desde que o esquema em si não seja modificado. As duas classes se tornaram vagamente acopladas.

Comentários

O XmlMessageFormatter é o formatador padrão que uma instância do MessageQueue usa para serializar mensagens gravadas na fila. Quando você cria uma instância de MessageQueue, uma instância de XmlMessageFormatter é criada para você e associada ao MessageQueue. Você pode especificar um formatador diferente criando-o em seu código e atribuindo-o Formatter à propriedade de seu MessageQueue.

A instância padrão XmlMessageFormatter de uma fila pode ser usada para gravar na fila, mas não pode ser usada para ler da fila até que você defina a TargetTypes propriedade ou TargetTypeNames no formatador. Você pode definir um ou ambos os valores na instância de formatador padrão ou criar uma nova instância do formatador e definir os valores automaticamente passando-os como argumentos para o construtor apropriado XmlMessageFormatter .

Ao especificar em vez de TargetTypes TargetTypeNames, a existência do tipo é verificada em tempo de compilação em vez de tempo de leitura, reduzindo a possibilidade de erro. TargetTypeNames requer que cada entrada seja totalmente qualificada, especificando seu nome de assembly. Além disso, ao trabalhar com várias versões simultâneas, o número de versão também deve ser acrescentado ao nome do tipo de destino.

As TargetTypeNames propriedades e TargetTypes informam ao formatador quais esquemas tentar corresponder ao desserializar uma mensagem. Isso permite que o formatador interprete o corpo da mensagem.

A instância serializada no corpo da mensagem deve estar em conformidade com um dos esquemas representados na matriz de tipos. Quando você lê a mensagem usando o Receive método , o método cria um objeto do tipo que corresponde ao esquema identificado e lê o corpo da mensagem nele.

Apenas uma das duas propriedades precisa ser definida ao ler da fila, mas você pode definir ambas. O conjunto de tipos é o conjunto combinado das duas propriedades. A decisão de qual propriedade usar é específica para seu aplicativo. Se o corpo da mensagem contiver um tipo cujo esquema não corresponde a nenhum dos tipos na matriz de nenhuma das propriedades, uma exceção será gerada quando a mensagem for lida.

O XmlMessageFormatter é um componente crucial de mensagens baseadas em XML acopladas livremente. O utilitário XSD.exe usa o formato XML é usado para gerar esquema XML, como quando você usa o utilitário para serializar uma classe usada pelo aplicativo. A classe deve ter um construtor sem parâmetros.

O formato é usado novamente no processo inverso quando o utilitário gera uma classe com base no esquema que você distribui para descrever seus dados de classe. O uso do utilitário e do esquema XML gerados permite evitar redistributing.dll arquivos sempre que você recompilar uma classe após a alteração da implementação da classe. Desde que o esquema não seja alterado no cliente ou no servidor, outras alterações em ambos os lados não afetam a outra.

Construtores

XmlMessageFormatter()	Inicializa uma nova instância da classe XmlMessageFormatter, sem tipos de destino definidos.
XmlMessageFormatter(String[])	Inicializa uma nova instância da classe XmlMessageFormatter, definindo os tipos de destino passados como uma matriz de valores de cadeia de caracteres (totalmente qualificados).
XmlMessageFormatter(Type[])	Inicializa uma nova instância da classe XmlMessageFormatter, definindo tipos de destino transmitidos como uma matriz de tipos de objeto.

Propriedades

TargetTypeNames	Especifica o conjunto de tipos possíveis que serão desserializados pelo formatador da mensagem fornecida.
TargetTypes	Especifica o conjunto de tipos possíveis que serão desserializados pelo formatador da mensagem fornecida.

Métodos

CanRead(Message)	Determina se o formatador pode desserializar a mensagem.
Clone()	Cria uma instância da classe XmlMessageFormatter cujas propriedades de leitura/gravação (os conjuntos dos tipos de destino) são as mesmas que a instância XmlMessageFormatter atual.
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)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
Read(Message)	Lê o conteúdo de determinada mensagem e cria um objeto que contém a mensagem desserializada.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
Write(Message, Object)	Serializa um objeto no corpo da mensagem.

Aplica-se a

Compartilhar via