XmlMessageFormatter Classe

Definição

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 seguinte exemplo de código inclui três pedaços de código: um componente de servidor, uma classe de ordem e código cliente. A classe order pode ser usada pela utilitária XSD.exe para gerar um esquema que o servidor reconhece nas mensagens recebidas. O esquema é um ficheiro formatado em XML que descreve a "forma" da classe. Este esquema pode então ser usado do lado do cliente para gerar uma classe de ordem específica do cliente que partilhe o mesmo esquema da classe servidor.

O seguinte exemplo de código representa um componente de servidor que recebe ordens através de uma fila de mensagens. O corpo da mensagem deve ser um objeto de ordem cujo esquema corresponde à classe Order.cs abaixo. O processo servidor ou a aplicação 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 seguinte representa a classe order que fornece um esquema para os objetos order que a aplicação 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 aplicação cliente que interaja com a aplicação no servidor deve enviar mensagens ao servidor serializando informação numa classe de ordem definida localmente para o corpo da mensagem. A classe de ordem definida localmente deve ter o mesmo esquema da classe de ordem definida pelo servidor, na qual a aplicação no servidor tentará desserializar o corpo da mensagem. A utilidade XSD.exe permite que o gestor da aplicação no servidor crie e distribua o esquema que o cliente deve usar para serializar as mensagens que chegam ao servidor.

Quando o gestor da aplicação cliente recebe o esquema da classe de ordem, a utilidade XSD.exe é usada novamente para gerar uma classe de ordem específica do cliente a partir do esquema. É esta classe que é usada no exemplo do código cliente abaixo, não a classe de ordem do servidor (a utilidade XSD.exe faz com que a classe gerada pelo esquema tenha o mesmo nome da classe original). Esta nova classe de ordem é usada para serializar a ordem no corpo da mensagem.

O exemplo de código seguinte é o processamento do lado do cliente, usado para serializar uma ordem e enviar a informação associada à ordem 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 pela utilidade XSD.exe. Uma ordem é enviada para a fila de Ordens 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 de o esquema ser gerado a partir da classe order no servidor, podes modificar a classe. A menos que o esquema mude, não precisa de redistribuí-lo. Depois de distribuir o esquema e gerar uma classe de ordem do lado do cliente, essa classe cliente também pode ser modificada independentemente da classe de ordem do servidor, desde que o próprio esquema não seja modificado. As duas classes tornaram-se vagamente ligadas.

Observações

É XmlMessageFormatter o formatador padrão que uma instância de MessageQueue usa para serializar mensagens escritas para a fila. Quando cria uma instância de MessageQueue, uma instância de XmlMessageFormatter é criada para si e associada ao MessageQueue. Pode especificar um formador diferente criando-o no seu código e atribuindo-o à Formatter propriedade do seu MessageQueue.

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

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

As TargetTypeNames propriedades e TargetTypes indicam ao formatter quais os esquemas a tentar corresponder ao desserializar uma mensagem. Isto permite que o formatador interprete o corpo da mensagem.

A instância serializada no corpo da mensagem deve cumprir um dos esquemas representados no array de tipos. Quando 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 de ser definida ao ler da fila, mas pode definir ambas. O conjunto dos tipos é o conjunto combinado das duas propriedades. A decisão sobre qual propriedade usar é específica para a sua candidatura. Se o corpo da mensagem contiver um tipo cujo esquema não corresponde a nenhum dos tipos do array para qualquer uma das propriedades, será lançada uma exceção quando a mensagem for lida.

Este XmlMessageFormatter é um componente crucial da comunicação baseada em XML pouco acoplada. A utilidade XSD.exe utiliza o formato XML para gerar o esquema XML, como quando usa a ferramenta para serializar uma classe usada pela sua aplicação. A classe deve ter um construtor sem parâmetros.

O formato é usado novamente no processo inverso quando a ferramenta gera uma classe baseada no esquema que distribui para descrever os dados da sua classe. A utilização da utilidade e do esquema XML que esta gera permite-lhe evitar redistributing.dll ficheiros sempre que recompila uma classe depois de a implementação da sua classe ter mudado. Desde que o esquema não mude no cliente ou no servidor, outras alterações de qualquer lado não afetam o outro.

Ver também

• MessageQueue
• ActiveXMessageFormatter
• BinaryMessageFormatter
• IMessageFormatter