XmlMessageFormatter Classe

Définition

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

Héritage

Object

XmlMessageFormatter

Implémente

ICloneable IMessageFormatter

Exemples

L’exemple de code suivant inclut trois éléments de code : un composant serveur, une classe de commande et du code client. La classe order peut être utilisée par l’utilitaire XSD.exe pour générer le schéma que le serveur reconnaît dans les messages entrants. Le schéma est un fichier au format XML qui décrit la « forme » de la classe. Ce schéma peut ensuite être utilisé côté client pour générer une classe de commande spécifique au client qui partage le même schéma que la classe serveur.

L’exemple de code suivant représente un composant serveur qui reçoit des commandes via une file d’attente de messages. Le corps du message doit être un objet order dont le schéma correspond à la classe Order.cs ci-dessous. Le processus serveur ou l’application désérialise la commande.

#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’exemple de code suivant représente la classe order qui fournit un schéma pour les objets order que l’application sur le serveur reçoit et désérialise.

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

Toute application cliente qui interagit avec l’application sur le serveur doit envoyer des messages au serveur en sérialisant les informations dans une classe d’ordre définie localement dans le corps du message. La classe d’ordre définie localement doit avoir le même schéma que la classe d’ordre définie par le serveur dans laquelle l’application sur le serveur tentera de désérialiser le corps du message. L’utilitaire XSD.exe permet au gestionnaire de l’application sur le serveur de créer et de distribuer le schéma que le client doit utiliser pour sérialiser les messages envoyés au serveur.

Lorsque le gestionnaire de l’application cliente reçoit le schéma de la classe order, l’utilitaire XSD.exe est à nouveau utilisé pour générer une classe de commande spécifique au client à partir du schéma. C’est cette classe qui est utilisée dans l’exemple de code client ci-dessous, et non la classe order du serveur (l’utilitaire XSD.exe fait que la classe générée par le schéma porte le même nom que la classe d’origine). Cette nouvelle classe d’ordre est utilisée pour sérialiser l’ordre dans le corps du message.

L’exemple de code suivant est le traitement côté client, utilisé pour sérialiser une commande et envoyer les informations associées à la commande à une file d’attente. Le code associe les informations Item, Quantity et Address aux éléments du schéma qui ont été générés pour la classe Order.cs par l’utilitaire XSD.exe. Une commande est envoyée à la file d’attente Commandes sur l’ordinateur 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

Une fois le schéma généré à partir de la classe order sur le serveur, vous pouvez modifier la classe . À moins que le schéma ne change, vous n’avez pas besoin de redistribuer le schéma. Une fois que vous avez distribué le schéma et généré une classe de commande côté client, cette classe cliente peut également être modifiée indépendamment de la classe order du serveur, tant que le schéma lui-même n’est pas modifié. Les deux classes sont devenues faiblement couplées.

Remarques

XmlMessageFormatter Est le formateur par défaut qu’un instance de MessageQueue utilise pour sérialiser les messages écrits dans la file d’attente. Lorsque vous créez un instance de MessageQueue, un instance de XmlMessageFormatter est créé pour vous et associé à .MessageQueue Vous pouvez spécifier un autre formateur en le créant dans votre code et en l’affectant à la Formatter propriété de votre MessageQueue.

Le instance par défaut XmlMessageFormatter d’une file d’attente peut être utilisé pour écrire dans la file d’attente, mais il ne peut pas être utilisé pour lire à partir de la file d’attente tant que vous n’avez pas défini la TargetTypes propriété ou TargetTypeNames sur le formateur. Vous pouvez définir l’une de ces valeurs ou les deux sur le formateur par défaut instance, ou créer une nouvelle instance du formateur et définir automatiquement les valeurs en les transmettant en tant qu’arguments au constructeur appropriéXmlMessageFormatter.

Lorsque vous spécifiez TargetTypes plutôt que TargetTypeNames, l’existence du type est vérifiée au moment de la compilation plutôt qu’au moment de la lecture, ce qui réduit le risque d’erreur. TargetTypeNames exige que chaque entrée soit complète, en spécifiant son nom d’assembly. En outre, lorsque vous utilisez plusieurs versions simultanées, le numéro de version doit également être ajouté au nom du type cible.

Les TargetTypeNames propriétés et TargetTypes indiquent au formateur les schémas à essayer de faire correspondre lors de la désérialisation d’un message. Cela permet au formateur d’interpréter le corps du message.

Le instance sérialisé dans le corps du message doit être conforme à l’un des schémas représentés dans le tableau de types. Lorsque vous lisez le message à l’aide de la Receive méthode, la méthode crée un objet du type qui correspond au schéma identifié et lit le corps du message dans celui-ci.

Une seule des deux propriétés doit être définie lors de la lecture à partir de la file d’attente, mais vous pouvez définir les deux. L’ensemble de types est l’ensemble combiné des deux propriétés. La décision de la propriété à utiliser est spécifique à votre application. Si le corps du message contient un type dont le schéma ne correspond à aucun des types du tableau pour l’une ou l’autre propriété, une exception est levée lorsque le message est lu.

Le XmlMessageFormatter est un composant essentiel de la messagerie xml faiblement couplée. L’utilitaire XSD.exe utilise le format XML pour générer un schéma XML, par exemple lorsque vous utilisez l’utilitaire pour sérialiser une classe utilisée par votre application. La classe doit avoir un constructeur sans paramètre.

Le format est à nouveau utilisé dans le processus inverse lorsque l’utilitaire génère une classe basée sur le schéma que vous distribuez pour décrire vos données de classe. L’utilisation de l’utilitaire et du schéma XML qu’il génère vous permet d’éviter redistributing.dll fichiers chaque fois que vous recompilez une classe après la modification de l’implémentation de votre classe. Tant que le schéma ne change pas sur le client ou le serveur, d’autres modifications de chaque côté n’affectent pas l’autre.

Constructeurs

Propriétés

Méthodes

S’applique à

Voir aussi

• MessageQueue
• ActiveXMessageFormatter
• BinaryMessageFormatter
• IMessageFormatter