XmlMessageFormatter Classe

Definizione

Serializza e deserializza oggetti nel e dal corpo di un messaggio, utilizzando il formato XML basato sulla definizione di schema 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
Ereditarietà
XmlMessageFormatter
Implementazioni

Esempi

L'esempio di codice seguente include tre frammenti di codice: un componente server, una classe Order e un codice client.The following code example includes three pieces of code: a server component, an order class, and client code. La classe Order può essere utilizzata dall'utilità XSD. exe per generare lo schema riconosciuto dal server all'interno dei messaggi in ingresso.The order class can be used by the XSD.exe utility to generate schema that the server recognizes within incoming messages. Lo schema è un file in formato XML che descrive la "forma" della classe.The schema is an XML formatted file that describes the "shape" of the class. Questo schema può quindi essere utilizzato sul lato client per generare una classe Order specifica del client che condivide lo stesso schema della classe server.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.

Nell'esempio di codice seguente viene rappresentato un componente server che riceve gli ordini tramite una coda di messaggi.The following code example represents a server component that receives orders through a message queue. Il corpo del messaggio deve essere un oggetto Order il cui schema corrisponde alla classe Order.cs riportata di seguito.The body of the message should be an order object whose schema matches the Order.cs class below. Il processo server o l'applicazione deserializza l'ordine.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.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

Nell'esempio di codice seguente viene rappresentata la classe Order che fornisce uno schema per gli oggetti Order ricevuti e deserializzati dall'applicazione nel server.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. */
 
     }
 }
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

Tutte le applicazioni client che interagiscono con l'applicazione sul server devono inviare messaggi al server tramite la serializzazione delle informazioni in una classe Order definita localmente nel corpo del messaggio.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 classe Order definita localmente deve avere lo stesso schema della classe Order definita dal server in cui l'applicazione nel server tenterà di deserializzare il corpo del messaggio.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. L'utilità XSD. exe consente al responsabile dell'applicazione nel server di creare e distribuire lo schema che il client deve utilizzare per serializzare i messaggi che passano al server.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.

Quando il responsabile dell'applicazione client riceve lo schema per la classe Order, l'utilità XSD. exe viene nuovamente utilizzata per generare una classe Order specifica del client dallo schema.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. Si tratta di questa classe utilizzata nell'esempio di codice client riportato di seguito, non della classe Order del server. l'utilità XSD. exe fa sì che la classe generata dallo schema abbia lo stesso nome della classe originale.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). Questa nuova classe Order viene utilizzata per serializzare l'ordine nel corpo del messaggio.This new order class is used to serialize the order into the message body.

L'esempio di codice seguente è l'elaborazione sul lato client, usata per serializzare un ordine e inviare le informazioni associate all'ordine a una coda.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. Il codice associa informazioni sull'elemento, sulla quantità e sull'indirizzo con gli elementi dello schema generati per la classe Order.cs dall'utilità 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. Un ordine viene inviato alla coda Orders sul computer locale.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.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

Dopo che lo schema è stato generato dalla classe Order nel server, è possibile modificare la classe.After the schema is generated from the order class on the server, you can modify the class. A meno che lo schema non venga modificato, non è necessario ridistribuire lo schema.Unless the schema changes, you do not need to redistribute the schema. Dopo la distribuzione dello schema e la generazione di una classe Order lato client, tale classe client può essere modificata anche indipendentemente dalla classe Order del server, purché lo schema stesso non venga modificato.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. Le due classi sono diventate a regime di controllo libero.The two classes have become loosely coupled.

Commenti

È il formattatore predefinito utilizzato da un'istanza MessageQueue di per serializzare i messaggi scritti nella coda. XmlMessageFormatterThe XmlMessageFormatter is the default formatter that an instance of MessageQueue uses to serialize messages written to the queue. Quando si crea un'istanza di MessageQueue, un'istanza di XmlMessageFormatter viene creata automaticamente e associata a MessageQueue.When you create an instance of MessageQueue, an instance of XmlMessageFormatter is created for you and associated with the MessageQueue. Per specificare un formattatore diverso, è possibile crearlo nel codice e assegnarlo alla Formatter proprietà MessageQueuedell'oggetto.You can specify a different formatter by creating it in your code and assigning it to the Formatter property of your MessageQueue.

L'istanza predefinita XmlMessageFormatter di una coda può essere utilizzata per scrivere nella coda, ma non può essere utilizzata per leggere dalla coda fino a quando non si imposta TargetTypes la TargetTypeNames proprietà o sul formattatore.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. È possibile impostare uno o entrambi questi valori sull'istanza del formattatore predefinita oppure creare una nuova istanza del formattatore e impostare automaticamente i valori passandoli come argomenti nel costruttore appropriato XmlMessageFormatter .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.

Quando si TargetTypes specifica invece TargetTypeNamesdi, l'esistenza del tipo viene controllata in fase di compilazione anziché in fase di lettura, riducendo la possibilità di errore.When specifying TargetTypes rather than TargetTypeNames, type existence is checked at compile time rather than read time, reducing possibility for error. TargetTypeNamesrichiede che ogni voce sia completamente qualificata, specificando il nome dell'assembly.TargetTypeNames requires every entry to be fully qualified, specifying its assembly name. Inoltre, quando si utilizzano più versioni simultanee, anche il numero di versione deve essere aggiunto al nome del tipo di destinazione.Further, when working with multiple concurrent versions, the version number must also be appended to the target type name as well.

Le TargetTypeNames proprietà TargetTypes e indicano al formattatore quali schemi tentare di trovare una corrispondenza durante la deserializzazione di un messaggio.The TargetTypeNames and TargetTypes properties tell the formatter what schemas to attempt to match when deserializing a message. Ciò consente al formattatore di interpretare il corpo del messaggio.This allows the formatter to interpret the message body.

L'istanza serializzata nel corpo del messaggio deve essere conforme a uno degli schemi rappresentati nella matrice di tipi.The instance serialized in the message body must comply with one of the schemas represented in the type array. Quando si legge il messaggio usando il Receive metodo, il metodo crea un oggetto del tipo che corrisponde allo schema identificato e ne legge il corpo del messaggio.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.

È necessario impostare solo una delle due proprietà durante la lettura dalla coda, ma è possibile impostare entrambe.Only one of the two properties needs to be set when reading from the queue, but you can set both. Il set di tipi è il set combinato dalle due proprietà.The set of types is the combined set from the two properties. La decisione della proprietà da usare è specifica dell'applicazione.The decision of which property to use is specific to your application. Se il corpo del messaggio contiene un tipo il cui schema non corrisponde ad alcuno dei tipi nella matrice per entrambe le proprietà, verrà generata un'eccezione quando il messaggio viene letto.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.

XmlMessageFormatter È un componente fondamentale della messaggistica basata su XML a regime di controllo libero.The XmlMessageFormatter is a crucial component of loosely coupled XML-based messaging. L'utilità XSD. exe utilizza il formato XML utilizzato per generare XML Schema, ad esempio quando si utilizza l'utilità per serializzare una classe utilizzata dall'applicazione.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 classe deve avere un costruttore senza parametri.The class must have a parameterless constructor.

Il formato viene nuovamente utilizzato nel processo inverso quando l'utilità genera una classe basata sullo schema distribuito per descrivere i dati della classe.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. L'uso dell'utilità e del XML Schema che genera consente di evitare la ridistribuzione dei file con estensione dll ogni volta che si ricompila una classe dopo che l'implementazione della classe è cambiata.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. Finché lo schema non viene modificato nel client o nel server, altre modifiche su entrambi i lati non influiscono sull'altro.As long as the schema does not change on the client or the server, other changes on either side do not affect the other.

Costruttori

XmlMessageFormatter()

Inizializza una nuova istanza della classe XmlMessageFormatter senza tipi di destinazione impostati.Initializes a new instance of the XmlMessageFormatter class, without target types set.

XmlMessageFormatter(String[])

Inizializza una nuova istanza della classe XmlMessageFormatter impostando i tipi di destinazione passati come matrice di valori di stringa (completamente qualificati).Initializes a new instance of the XmlMessageFormatter class, setting target types passed in as an array of (fully qualified) string values.

XmlMessageFormatter(Type[])

Inizializza una nuova istanza della classe XmlMessageFormatter impostando i tipi di destinazione passati come matrice di tipi di oggetti.Initializes a new instance of the XmlMessageFormatter class, setting target types passed in as an array of object types.

Proprietà

TargetTypeNames

Specifica l'insieme di tipi possibili che verranno deserializzati tramite il formattatore dal messaggio fornito.Specifies the set of possible types that will be deserialized by the formatter from the message provided.

TargetTypes

Specifica l'insieme di tipi possibili che verranno deserializzati tramite il formattatore dal messaggio fornito.Specifies the set of possible types that will be deserialized by the formatter from the message provided.

Metodi

CanRead(Message)

Determina se il formattatore può deserializzare il messaggio.Determines whether the formatter can deserialize the message.

Clone()

Crea un'istanza della classe XmlMessageFormatter le cui proprietà di lettura/scrittura (gli insiemi dei tipi di destinazione) sono le stesse dell'istanza XmlMessageFormatter corrente.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)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
Read(Message)

Legge il contenuto del messaggio indicato e crea un oggetto contenente il messaggio deserializzato.Reads the contents from the given message and creates an object that contains the deserialized message.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
Write(Message, Object)

Serializza un oggetto nel corpo del messaggio.Serializes an object into the body of the message.

Si applica a

Vedi anche