XmlMessageFormatter Clase

Definición

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

Herencia

Object

XmlMessageFormatter

Implementaciones

ICloneable IMessageFormatter

Ejemplos

En el ejemplo de código siguiente se incluyen tres fragmentos de código: un componente de servidor, una clase order y un código de cliente. La utilidad XSD.exe puede usar la clase order para generar el esquema que el servidor reconoce dentro de los mensajes entrantes. El esquema es un archivo con formato XML que describe la "forma" de la clase . A continuación, este esquema se puede usar en el lado cliente para generar una clase de pedido específica del cliente que comparta el mismo esquema que la clase de servidor.

En el ejemplo de código siguiente se representa un componente de servidor que recibe pedidos a través de una cola de mensajes. El cuerpo del mensaje debe ser un objeto order cuyo esquema coincida con la clase Order.cs siguiente. El proceso de servidor o la aplicación deserializa el orden.

#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

En el ejemplo de código siguiente se representa la clase order que proporciona un esquema para los objetos order que recibe y deserializa la aplicación en el servidor.

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

Cualquier aplicación cliente que interactúe con la aplicación en el servidor debe enviar mensajes al servidor mediante la serialización de información en una clase de orden definida localmente en el cuerpo del mensaje. La clase de orden definida localmente debe tener el mismo esquema que la clase de orden definida por el servidor en la que la aplicación del servidor intentará deserializar el cuerpo del mensaje. La utilidad XSD.exe permite al administrador de la aplicación en el servidor crear y distribuir el esquema que el cliente debe usar para serializar los mensajes que van al servidor.

Cuando el administrador de la aplicación cliente recibe el esquema de la clase order, la utilidad XSD.exe se usa de nuevo para generar una clase de pedido específica del cliente a partir del esquema. Es esta clase que se usa en el ejemplo de código de cliente siguiente, no la clase order del servidor (la utilidad XSD.exe hace que la clase generada por el esquema tenga el mismo nombre que la clase original). Esta nueva clase de orden se usa para serializar el orden en el cuerpo del mensaje.

El siguiente ejemplo de código es el procesamiento del lado cliente, que se usa para serializar un pedido y enviar la información asociada al pedido a una cola. El código asocia la información Item, Quantity y Address con los elementos del esquema generados para la clase Order.cs por la utilidad XSD.exe. Se envía un pedido a la cola Pedidos en el equipo 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

Una vez generado el esquema a partir de la clase order en el servidor, puede modificar la clase . A menos que cambie el esquema, no es necesario redistribuir el esquema. Después de distribuir el esquema y generar una clase de orden del lado cliente, esa clase de cliente también se puede modificar independientemente de la clase order del servidor, siempre y cuando el propio esquema no se modifique. Las dos clases se han acoplado de forma flexible.

Comentarios

XmlMessageFormatter es el formateador predeterminado que usa una instancia de MessageQueue para serializar los mensajes escritos en la cola. Cuando se crea una instancia de MessageQueue, se crea una instancia de XmlMessageFormatter para usted y se asocia con .MessageQueue Puede especificar otro formateador si lo crea en el código y lo asigna a la Formatter propiedad de .MessageQueue

La instancia predeterminada XmlMessageFormatter de una cola se puede usar para escribir en la cola, pero no se puede usar para leer desde la cola hasta que establezca la TargetTypes propiedad o TargetTypeNames en el formateador. Puede establecer uno o ambos valores en la instancia de formateador predeterminada, o bien puede crear una nueva instancia del formateador y establecer automáticamente los valores pasandolos como argumentos al constructor adecuado XmlMessageFormatter .

Al especificar TargetTypes en lugar de TargetTypeNames, la existencia de tipos se comprueba en tiempo de compilación en lugar de tiempo de lectura, lo que reduce la posibilidad de error. TargetTypeNames requiere que cada entrada esté completa y especifique su nombre de ensamblado. Además, al trabajar con varias versiones simultáneas, el número de versión también debe anexarse al nombre del tipo de destino.

Las TargetTypeNames propiedades y TargetTypes indican al formateador qué esquemas deben intentar coincidir al deserializar un mensaje. Esto permite al formateador interpretar el cuerpo del mensaje.

La instancia serializada en el cuerpo del mensaje debe cumplir uno de los esquemas representados en la matriz de tipos. Cuando se lee el mensaje mediante el Receive método , el método crea un objeto del tipo que corresponde al esquema identificado y lee el cuerpo del mensaje en él.

Solo es necesario establecer una de las dos propiedades al leer desde la cola, pero puede establecer ambas. El conjunto de tipos es el conjunto combinado de las dos propiedades. La decisión de qué propiedad usar es específica de la aplicación. Si el cuerpo del mensaje contiene un tipo cuyo esquema no coincide con ninguno de los tipos de la matriz para cualquiera de las propiedades , se producirá una excepción cuando se lea el mensaje.

XmlMessageFormatter es un componente fundamental de la mensajería basada en XML de acoplamiento flexible. La utilidad XSD.exe usa el formato XML para generar un esquema XML, como cuando se usa la utilidad para serializar una clase usada por la aplicación. La clase debe tener un constructor sin parámetros.

El formato se usa de nuevo en el proceso inverso cuando la utilidad genera una clase basada en el esquema que distribuye para describir los datos de clase. El uso de la utilidad y el esquema XML que genera le permite evitar redistributing.dll archivos cada vez que vuelva a compilar una clase después de que haya cambiado la implementación de la clase. Siempre que el esquema no cambie en el cliente o en el servidor, otros cambios en ambos lados no afectan al otro.

Constructores

Propiedades

Métodos

Se aplica a

Consulte también

• MessageQueue
• ActiveXMessageFormatter
• BinaryMessageFormatter
• IMessageFormatter