XmlMessageFormatter Classe

Definizione

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 order 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 in formato 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 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 order che fornisce uno schema per gli oggetti order ricevuti e deserializzati dall'applicazione nel server.

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 localmente nel corpo del messaggio. La classe order definita localmente 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 al gestore dell'applicazione nel server di creare e distribuire lo schema che il client deve usare per serializzare i messaggi che passano al server.

Quando il gestore dell'applicazione client riceve lo schema per la classe order, 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 nella classe order del server ( l'utilità XSD.exe fa sì che la classe generata dallo schema abbia lo stesso nome della classe originale). Questa nuova classe order 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 venga modificato, non è necessario ridistribuire lo schema. Dopo aver distribuito lo schema e generato una classe di ordine lato client, tale classe client può anche essere modificata indipendentemente dalla classe order del server, purché lo schema stesso non venga modificato. Le due classi sono diventate ad accoppiamento libero.

Commenti

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

L'istanza predefinita XmlMessageFormatter di una coda può essere usata per scrivere nella coda, ma non può essere usata per leggere dalla coda finché 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 TargetTypes specifica anziché TargetTypeNames, l'esistenza del tipo viene verificata in fase di compilazione anziché in fase di lettura, riducendo la possibilità di errori. TargetTypeNames richiede che ogni voce sia completa, specificando il nome dell'assembly. Inoltre, quando si usano più versioni simultanee, anche il numero di versione deve essere aggiunto al nome del tipo di destinazione.

Le TargetTypeNames proprietà e TargetTypes indicano al formattatore quali schemi tentare di trovare una corrispondenza durante la deserializzazione di un messaggio. In questo modo il formattatore può 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.

È necessario impostare solo una delle due proprietà durante la lettura dalla coda, ma è possibile impostare entrambe le proprietà. Il set di tipi è il set combinato delle due proprietà. La decisione della proprietà da usare è specifica per l'applicazione. Se il corpo del messaggio contiene un tipo il cui schema non corrisponde ad alcun tipo nella matrice per entrambe le proprietà, viene generata un'eccezione quando il messaggio viene letto.

è XmlMessageFormatter un componente fondamentale della messaggistica basata su XML ad accoppiamento 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 basata sullo 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. Se lo schema non cambia nel client o nel server, altre modifiche su entrambi i lati non influiscono sull'altro.

Costruttori

Proprietà

Metodi

Si applica a

Vedi anche

• MessageQueue
• ActiveXMessageFormatter
• BinaryMessageFormatter
• IMessageFormatter