XmlMessageFormatter Classe

Riferimento

Definizione

Spazio dei nomi:: System.Messaging

Assembly:: System.Messaging.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

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

Ereditarietà: Object
XmlMessageFormatter

Implementazioni: ICloneable IMessageFormatter

Esempio

L'esempio di codice seguente include tre parti di codice: un componente server, una classe di ordine e un codice client. La classe order può essere usata dall'utilità XSD.exe per generare lo schema riconosciuto dal server all'interno dei messaggi in ingresso. Lo schema è un file formattato XML che descrive la "forma" della classe. Questo schema può quindi essere usato sul lato client per generare una classe di ordine specifica del client che condivide lo stesso schema della classe server.

L'esempio di codice seguente rappresenta un componente server che riceve gli ordini tramite una coda di messaggi. Il corpo del messaggio deve essere un oggetto order il cui schema corrisponde alla classe Order.cs seguente. Il processo del server o l'applicazione deserializza l'ordine.

#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

L'esempio di codice seguente rappresenta la classe di ordine che fornisce uno schema per gli oggetti order ricevuti dall'applicazione nel server e deserializza.

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

Qualsiasi applicazione client che interagisce con l'applicazione nel server deve inviare messaggi al server serializzando le informazioni in una classe di ordine definita in locale nel corpo del messaggio. La classe di ordine definita in locale deve avere lo stesso schema della classe di ordine definita dal server in cui l'applicazione nel server tenterà di deserializzare il corpo del messaggio. L'utilità XSD.exe consente alla gestione dell'applicazione nel server di creare e distribuire lo schema che il client deve usare per serializzare i messaggi che andranno al server.

Quando il gestore dell'applicazione client riceve lo schema per la classe di ordine, l'utilità XSD.exe viene usata di nuovo per generare una classe di ordine specifica del client dallo schema. Si tratta di questa classe usata nell'esempio di codice client seguente, non della classe order del server (l'utilità XSD.exe causa la generazione dello schema di avere lo stesso nome della classe originale). Questa nuova classe di ordine viene usata per serializzare l'ordine nel corpo del messaggio.

L'esempio di codice seguente è l'elaborazione lato client, usata per serializzare un ordine e inviare le informazioni associate all'ordine a una coda. Il codice associa le informazioni Item, Quantity e Address agli elementi dello schema generati per la classe Order.cs dall'utilità XSD.exe. Un ordine viene inviato alla coda Orders nel computer locale.

#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 aver generato lo schema dalla classe order nel server, è possibile modificare la classe. A meno che lo schema non cambi, non è necessario ridistribuire lo schema. Dopo aver distribuito lo schema e generato una classe di ordine lato client, la classe client può essere modificata indipendentemente dalla classe dell'ordine del server, purché lo schema stesso non venga modificato. Le due classi sono diventate liberamente associate.

Commenti

È XmlMessageFormatter il formattatore predefinito usato da un'istanza di MessageQueue per serializzare i messaggi scritti nella coda. Quando si crea un'istanza di , viene creata un'istanza di MessageQueue XmlMessageFormatter e associata all'oggetto MessageQueue. È possibile specificare un formattatore diverso creandolo nel codice e assegnandolo alla proprietà dell'oggetto Formatter MessageQueue.

L'istanza predefinita XmlMessageFormatter di una coda può essere usata per scrivere nella coda, ma non può essere usata per leggere dalla coda fino a quando non si imposta la TargetTypes proprietà o TargetTypeNames nel formattatore. È possibile impostare uno o entrambi questi valori nell'istanza del formattatore predefinito oppure è possibile creare una nuova istanza del formattatore e impostare automaticamente i valori passandoli come argomenti nel costruttore appropriato XmlMessageFormatter .

Quando si specifica TargetTypes anziché TargetTypeNames, l'esistenza del tipo viene controllata in fase di compilazione anziché tempo di lettura, riducendo la possibilità di errore. TargetTypeNames richiede che ogni voce sia completa, specificando il nome dell'assembly. Inoltre, quando si utilizzano più versioni simultanee, il numero di versione deve essere aggiunto anche al nome del tipo di destinazione.

Le TargetTypeNames proprietà e TargetTypes indicano al formattatore gli schemi da provare a corrispondere quando si deserializzare un messaggio. Ciò consente al formattatore di interpretare il corpo del messaggio.

L'istanza serializzata nel corpo del messaggio deve essere conforme a uno degli schemi rappresentati nella matrice di tipi. Quando si legge il messaggio usando il Receive metodo, il metodo crea un oggetto del tipo che corrisponde allo schema identificato e legge il corpo del messaggio in esso.

Solo una delle due proprietà deve essere impostata durante la lettura dalla coda, ma è possibile impostare entrambe le proprietà. Il set di tipi è il set combinato delle due proprietà. La decisione di quale proprietà usare è specifica per l'applicazione. Se il corpo del messaggio contiene un tipo il cui schema non corrisponde a nessuno dei tipi nella matrice per entrambe le proprietà, verrà generata un'eccezione quando il messaggio viene letto.

Si XmlMessageFormatter tratta di un componente fondamentale della messaggistica basata su XML in modo libero. L'utilità XSD.exe usa il formato XML per generare XML Schema, ad esempio quando si usa l'utilità per serializzare una classe utilizzata dall'applicazione. La classe deve avere un costruttore senza parametri.

Il formato viene usato di nuovo nel processo inverso quando l'utilità genera una classe in base allo schema distribuito per descrivere i dati della classe. L'uso dell'utilità e dello schema XML generato consente di evitare redistributing.dll file ogni volta che si ricompila una classe dopo la modifica dell'implementazione della classe. Purché lo schema non cambi nel client o nel server, altre modifiche sul lato non influiscono sull'altro.

Costruttori

XmlMessageFormatter()	Inizializza una nuova istanza della classe XmlMessageFormatter senza tipi di destinazione impostati.
XmlMessageFormatter(String[])	Inizializza una nuova istanza della classe XmlMessageFormatter impostando i tipi di destinazione passati come matrice di valori di stringa (completamente qualificati).
XmlMessageFormatter(Type[])	Inizializza una nuova istanza della classe XmlMessageFormatter impostando i tipi di destinazione passati come matrice di tipi di oggetti.

Proprietà

TargetTypeNames	Specifica l'insieme di tipi possibili che verranno deserializzati tramite il formattatore dal messaggio fornito.
TargetTypes	Specifica l'insieme di tipi possibili che verranno deserializzati tramite il formattatore dal messaggio fornito.

Metodi

CanRead(Message)	Determina se il formattatore può deserializzare il messaggio.
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.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
Read(Message)	Legge il contenuto del messaggio indicato e crea un oggetto contenente il messaggio deserializzato.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
Write(Message, Object)	Serializza un oggetto nel corpo del messaggio.

Si applica a