XmlMessageFormatter XmlMessageFormatter XmlMessageFormatter XmlMessageFormatter Class

Definición

Serializa y deserializa objetos del cuerpo de un mensaje, utilizando el formato XML basado en la definición de esquemas XSD.Serializes and deserializes objects to or from the body of a message, using the XML format based on the XSD schema definition.

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
XmlMessageFormatterXmlMessageFormatterXmlMessageFormatterXmlMessageFormatter
Implementaciones

Ejemplos

El siguiente ejemplo de código incluye tres fragmentos de código: un componente de servidor, una clase order y el código de cliente.The following code example includes three pieces of code: a server component, an order class, and client code. La clase order se puede usar la utilidad XSD.exe para generar el esquema que el servidor reconoce dentro de los mensajes entrantes.The order class can be used by the XSD.exe utility to generate schema that the server recognizes within incoming messages. El esquema es un archivo con formato XML que describe la "forma" de la clase.The schema is an XML formatted file that describes the "shape" of the class. Este esquema se puede usar, a continuación, en el lado cliente para generar una clase de órdenes específica del cliente que comparte el mismo esquema que la clase de servidor.This schema can then be used on the client side to generate a client-specific order class that shares the same schema as the server class.

El siguiente ejemplo de código representa un componente de servidor que recibe pedidos a través de una cola de mensajes.The following code example represents a server component that receives orders through a message queue. El cuerpo del mensaje debe ser un objeto de pedido cuyo esquema coincide con la clase Order.cs siguiente.The body of the message should be an order object whose schema matches the Order.cs class below. El proceso de servidor o la aplicación deserializa el orden.The server process or application deserializes the order.

#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
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 'Main
    
    
    ' 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 'EnsureQueueExists
End Class 'Server

El ejemplo de código siguiente representa la clase order que proporciona un esquema para los objetos de pedido que recibe la aplicación en el servidor y los deserializa.The following code example represents the order class that provides a schema for the order objects that the application on the server receives and deserializes.

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. */
 
     }
 }
Imports System
Imports Microsoft.VisualBasic

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 'ShipItems 
End Class 'Order 

Cualquier aplicación cliente que interactúa con la aplicación en el servidor debe enviar mensajes al servidor serializando la información en una clase de orden definido localmente en el cuerpo del mensaje.Any client application that interacts with the application on the server must send messages to the server by serializing information in a locally defined order class into the message body. La clase order definida localmente debe tener el mismo esquema que la clase de orden definido por el servidor en el que la aplicación en el servidor intentará deserializar el cuerpo del mensaje.The locally defined order class must have the same schema as the server-defined order class into which the application on the server will attempt to deserialize the message body. La utilidad XSD.exe permite el Administrador de la aplicación en el servidor, crear y distribuir el esquema que el cliente debe utilizar para serializar los mensajes dirigidos al servidor.The XSD.exe utility lets the manager of the application on the server create and distribute the schema the client must use to serialize messages going to the server.

Cuando el Administrador de la aplicación cliente recibe el esquema para la clase order, la utilidad XSD.exe se utiliza de nuevo para generar una clase de órdenes específica del cliente desde el esquema.When the manager of the client application receives the schema for the order class, the XSD.exe utility is used again to generate a client-specific order class from the schema. Es la clase que se usa en el ejemplo de código de cliente a continuación, no la clase de orden del servidor (la utilidad XSD.exe hace que la clase generados por esquema tengan el mismo nombre que la clase original).It is this class that is used in the client code example below, not the server's order class (the XSD.exe utility causes the schema-generated class to have the same name as the original class). Esta nueva clase order se utiliza para serializar el orden en el cuerpo del mensaje.This new order class is used to serialize the order into the message body.

El siguiente ejemplo de código es el cliente de procesamiento, utilizado para serializar un pedido y enviar la información asociada con el orden en una cola.The following code example is the client-side processing, used to serialize an order and send the information associated with the order to a queue. El código asocia información de elemento, la cantidad y la dirección a los elementos del esquema que se generaron para la clase Order.cs por la utilidad XSD.exe.The code associates Item, Quantity, and Address information with elements of the schema that were generated for the Order.cs class by the XSD.exe utility. Se envía un pedido a la cola de pedidos en el equipo local.An order is sent to the Orders queue on the local computer.

#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
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 'Main
    
    ' 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 'EnsureQueueExists
End Class 'Client 

Una vez generado el esquema de la clase order en el servidor, puede modificar la clase.After the schema is generated from the order class on the server, you can modify the class. A menos que los cambios de esquema, no es necesario redistribuir el esquema.Unless the schema changes, you do not need to redistribute the schema. Después de haber distribuido el esquema y genera una clase de pedido de cliente, también puede modificarse esa clase de cliente independientemente de la clase del servidor orden, siempre que no se modifica el propio esquema.After you have distributed the schema and generated a client-side order class, that client class can also be modified independently of the server's order class, as long as the schema itself is not modified. Las dos clases se han convertido en imprecisa.The two classes have become loosely coupled.

Comentarios

El XmlMessageFormatter es el formateador predeterminado que una instancia de MessageQueue utiliza para serializar los mensajes enviados a la cola.The XmlMessageFormatter is the default formatter that an instance of MessageQueue uses to serialize messages written to the queue. Cuando se crea una instancia de MessageQueue, una instancia de XmlMessageFormatter se crea automáticamente y asociado con el MessageQueue.When you create an instance of MessageQueue, an instance of XmlMessageFormatter is created for you and associated with the MessageQueue. Puede especificar un formateador distinto, crearlo en el código y asígnela a la Formatter propiedad de su MessageQueue.You can specify a different formatter by creating it in your code and assigning it to the Formatter property of your MessageQueue.

Predeterminada de una cola XmlMessageFormatter instancia puede utilizarse para escribir en la cola, pero no se puede usar para leer la cola hasta que se establece la TargetTypes o TargetTypeNames propiedad en el formateador.A queue's default XmlMessageFormatter instance can be used to write to the queue, but it cannot be used to read from the queue until you set either the TargetTypes or TargetTypeNames property on the formatter. Se pueden establecer uno o ambos de estos valores en la instancia del formateador de forma predeterminada, o puede crear una nueva instancia del formateador y establecer los valores automáticamente al pasar como argumentos en el XmlMessageFormatter constructor.You can either set one or both of these values on the default formatter instance, or you can create a new instance of the formatter and set the values automatically by passing them as arguments into the appropriate XmlMessageFormatter constructor.

Al especificar TargetTypes lugar TargetTypeNames, tipo existencia se comprueba en tiempo de compilación en lugar de tiempo de lectura, lo que reduce la posibilidad de errores.When specifying TargetTypes rather than TargetTypeNames, type existence is checked at compile time rather than read time, reducing possibility for error. TargetTypeNames requiere que cada entrada estén completos, especificando su nombre de ensamblado.TargetTypeNames requires every entry to be fully qualified, specifying its assembly name. Además, cuando se trabaja con varias versiones simultáneas, también se debe anexar el número de versión para el nombre de tipo de destino.Further, when working with multiple concurrent versions, the version number must also be appended to the target type name as well.

El TargetTypeNames y TargetTypes propiedades indican el formateador los esquemas que intentan conciliar al deserializar un mensaje.The TargetTypeNames and TargetTypes properties tell the formatter what schemas to attempt to match when deserializing a message. Esto permite al formateador interpretar el cuerpo del mensaje.This allows the formatter to interpret the message body.

La instancia serializada en el cuerpo del mensaje debe cumplir uno de los esquemas que representan en la matriz de tipos.The instance serialized in the message body must comply with one of the schemas represented in the type array. Cuando se lee el mensaje utilizando 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.When you read the message using the Receive method, the method creates an object of the type that corresponds to the schema identified and reads the message body into it.

Solo una de las dos propiedades debe establecerse cuando se leen de la cola, pero se pueden establecer ambas.Only one of the two properties needs to be set when reading from the queue, but you can set both. El conjunto de tipos es el conjunto combinado de las dos propiedades.The set of types is the combined set from the two properties. La decisión de la propiedad que es específica de la aplicación.The decision of which property to use is specific to your application. Si el cuerpo del mensaje contiene un tipo cuyo esquema no coincide con cualquiera de los tipos de la matriz de cualquiera de las propiedades, se producirá una excepción cuando se lee el mensaje.If the message body contains a type whose schema does not match any of the types in the array for either property, an exception will be thrown when the message is read.

El XmlMessageFormatter es un componente fundamental de acoplamiento flexible de mensajería basado en XML.The XmlMessageFormatter is a crucial component of loosely coupled XML-based messaging. La utilidad XSD.exe emplea que el formato XML se usa para generar el esquema XML, como cuando se utiliza la utilidad para serializar una clase usada por la aplicación.The XSD.exe utility uses the XML format is used to generate XML schema, such as when you use the utility to serialize a class used by your application. La clase debe tener un constructor predeterminado.The class must have a default constructor.

Se utiliza el formato nuevo en el proceso inverso cuando la utilidad genera una clase basada en el esquema se distribuye para describir los datos de clase.The format is used again in the reverse process when the utility generates a class based on the schema you distribute to describe your class data. El uso de la utilidad y el esquema XML que genera permite evitar redistribuir archivos cada vez que vuelva a compilar una clase después de la implementación de la clase ha cambiado.The use of the utility and the XML schema it generates enables you to avoid redistributing.dll files every time you recompile a class after the implementation of your class has changed. No se modifica el esquema en el cliente o el servidor, siempre que otros cambios en cualquier lado no afecten a la otra.As long as the schema does not change on the client or the server, other changes on either side do not affect the other.

Constructores

XmlMessageFormatter() XmlMessageFormatter() XmlMessageFormatter() XmlMessageFormatter()

Inicializa una nueva instancia de la clase XmlMessageFormatter sin los tipos de destino establecidos.Initializes a new instance of the XmlMessageFormatter class, without target types set.

XmlMessageFormatter(String[]) XmlMessageFormatter(String[]) XmlMessageFormatter(String[]) XmlMessageFormatter(String[])

Inicializa una nueva instancia de la clase XmlMessageFormatter, estableciendo los tipos de destino pasados en forma de matriz de valores de cadena completos.Initializes a new instance of the XmlMessageFormatter class, setting target types passed in as an array of (fully qualified) string values.

XmlMessageFormatter(Type[]) XmlMessageFormatter(Type[]) XmlMessageFormatter(Type[]) XmlMessageFormatter(Type[])

Inicializa una nueva instancia de la clase XmlMessageFormatter, estableciendo los tipos de destino pasados en forma matriz de tipos de objetos.Initializes a new instance of the XmlMessageFormatter class, setting target types passed in as an array of object types.

Propiedades

TargetTypeNames TargetTypeNames TargetTypeNames TargetTypeNames

Especifica el conjunto de tipos posibles que el formateador deserializará a partir del mensaje proporcionado.Specifies the set of possible types that will be deserialized by the formatter from the message provided.

TargetTypes TargetTypes TargetTypes TargetTypes

Especifica el conjunto de tipos posibles que el formateador deserializará a partir del mensaje proporcionado.Specifies the set of possible types that will be deserialized by the formatter from the message provided.

Métodos

CanRead(Message) CanRead(Message) CanRead(Message) CanRead(Message)

Determina si el formateador puede deserializar el mensaje.Determines whether the formatter can deserialize the message.

Clone() Clone() Clone() Clone()

Crea una instancia de la clase XmlMessageFormatter cuyas propiedades de lectura y escritura (los conjuntos de tipos de destino) son las mismas que las de la instancia de XmlMessageFormatter actual.Creates an instance of the XmlMessageFormatter class whose read/write properties (the sets of target types) are the same as the current XmlMessageFormatter instance.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
Read(Message) Read(Message) Read(Message) Read(Message)

Lee el contenido del mensaje especificado y crea un objeto que contiene el mensaje deserializado.Reads the contents from the given message and creates an object that contains the deserialized message.

ToString() ToString() ToString() ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)
Write(Message, Object) Write(Message, Object) Write(Message, Object) Write(Message, Object)

Serializa un objeto en el cuerpo del mensaje.Serializes an object into the body of the message.

Se aplica a

Consulte también: