XmlMessageFormatter Klass

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

Arv

Object

XmlMessageFormatter

Implementeringar

ICloneable IMessageFormatter

Exempel

Följande kodexempel innehåller tre koddelar: en serverkomponent, en orderklass och klientkod. Orderklassen kan användas av verktyget XSD.exe för att generera ett schema som servern känner igen i inkommande meddelanden. Schemat är en XML-formaterad fil som beskriver klassens "form". Det här schemat kan sedan användas på klientsidan för att generera en klientspecifik orderklass som delar samma schema som serverklassen.

Följande kodexempel representerar en serverkomponent som tar emot beställningar via en meddelandekö. Meddelandets brödtext ska vara ett orderobjekt vars schema matchar Order.cs-klassen nedan. Serverprocessen eller programmet deserialiserar ordningen.

#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

Följande kodexempel representerar orderklassen som tillhandahåller ett schema för orderobjekten som programmet på servern tar emot och deserialiserar.

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

Alla klientprogram som interagerar med programmet på servern måste skicka meddelanden till servern genom att serialisera information i en lokalt definierad orderklass i meddelandetexten. Den lokalt definierade orderklassen måste ha samma schema som den serverdefinierade orderklassen där programmet på servern försöker deserialisera meddelandetexten. Med verktyget XSD.exe kan programhanteraren på servern skapa och distribuera schemat som klienten måste använda för att serialisera meddelanden som går till servern.

När chefen för klientprogrammet tar emot schemat för orderklassen används XSD.exe-verktyget igen för att generera en klientspecifik orderklass från schemat. Det är den här klassen som används i klientkodexemplet nedan, inte serverns orderklass (XSD.exe-verktyget gör att den schemagenererade klassen har samma namn som den ursprungliga klassen). Den här nya orderklassen används för att serialisera ordningen i meddelandetexten.

Följande kodexempel är bearbetningen på klientsidan, som används för att serialisera en order och skicka den information som är associerad med ordern till en kö. Koden associerar information om objekt, kvantitet och adress med element i schemat som genererades för klassen Order.cs av verktyget XSD.exe. En order skickas till kön Beställningar på den lokala datorn.

#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

När schemat har genererats från orderklassen på servern kan du ändra klassen. Om inte schemat ändras behöver du inte omdistribuera schemat. När du har distribuerat schemat och genererat en orderklass på klientsidan kan den klientklassen också ändras oberoende av serverns orderklass, så länge själva schemat inte ändras. De två klasserna har blivit löst kopplade.

Kommentarer

XmlMessageFormatter är standardformaterare som en instans av MessageQueue använder för att serialisera meddelanden som skrivits till kön. När du skapar en instans av MessageQueueskapas en instans av XmlMessageFormatter åt dig och associeras med MessageQueue. Du kan ange en annan formatering genom att skapa den i koden och tilldela den Formatter till egenskapen för din MessageQueue.

En kös standardinstans XmlMessageFormatter kan användas för att skriva till kön, men den kan inte användas för att läsa från kön förrän du har angett antingen TargetTypes egenskapen eller TargetTypeNames i formateren. Du kan antingen ange ett eller båda av dessa värden på standardformateringsinstansen, eller så kan du skapa en ny instans av formatören och ange värdena automatiskt genom att skicka dem som argument till lämplig XmlMessageFormatter konstruktor.

När du TargetTypes anger i stället TargetTypeNameskontrolleras typexistensen vid kompileringstid i stället för lästid, vilket minskar risken för fel. TargetTypeNames kräver att varje post är fullständigt kvalificerad och anger dess sammansättningsnamn. När du arbetar med flera samtidiga versioner måste versionsnumret också läggas till i måltypnamnet.

Egenskaperna TargetTypeNames och TargetTypes talar om för formatören vilka scheman som ska försöka matcha när ett meddelande deserialiseras. Detta gör att formaterare kan tolka meddelandetexten.

Instansen som serialiseras i meddelandetexten måste följa något av schemana som representeras i typmatrisen. När du läser meddelandet med metoden Receive skapar metoden ett objekt av den typ som motsvarar schemat som identifierats och läser in meddelandetexten i det.

Endast en av de två egenskaperna måste anges när du läser från kön, men du kan ange båda. Uppsättningen med typer är den kombinerade uppsättningen från de två egenskaperna. Beslutet om vilken egenskap som ska användas är specifikt för ditt program. Om meddelandetexten innehåller en typ vars schema inte matchar någon av typerna i matrisen för någon av egenskaperna genereras ett undantag när meddelandet läses.

XmlMessageFormatter Är en viktig komponent i löst kopplade XML-baserade meddelanden. Verktyget XSD.exe använder XML-formatet för att generera XML-schema, till exempel när du använder verktyget för att serialisera en klass som används av ditt program. Klassen måste ha en parameterlös konstruktor.

Formatet används igen i omvänd process när verktyget genererar en klass baserat på det schema som du distribuerar för att beskriva dina klassdata. Med hjälp av verktyget och XML-schemat som genereras kan du undvika att redistributing.dll filer varje gång du kompilera om en klass efter att implementeringen av klassen har ändrats. Så länge schemat inte ändras på klienten eller servern påverkar inte andra ändringar på båda sidor den andra.

Se även

• MessageQueue
• ActiveXMessageFormatter
• BinaryMessageFormatter
• IMessageFormatter