XmlMessageFormatter Třída

Definice

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

Dědičnost

Object

XmlMessageFormatter

Implementuje

ICloneable IMessageFormatter

Příklady

Následující příklad kódu obsahuje tři části kódu: součást serveru, třídu objednávky a klientský kód. Třídu order může použít nástroj XSD.exe ke generování schématu, které server rozpozná v příchozích zprávách. Schéma je soubor ve formátu XML, který popisuje "tvar" třídy. Toto schéma pak lze použít na straně klienta ke generování třídy objednávky specifické pro klienta, která sdílí stejné schéma jako serverová třída.

Následující příklad kódu představuje serverovou komponentu, která přijímá objednávky prostřednictvím fronty zpráv. Text zprávy by měl být objekt objednávky, jehož schéma odpovídá Order.cs třídě níže. Proces serveru nebo aplikace deserializuje pořadí.

#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

Následující příklad kódu představuje třídu order, která poskytuje schéma pro order objekty, které aplikace na serveru obdrží a deserializuje.

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

Každá klientská aplikace, která komunikuje s aplikací na serveru, musí odesílat zprávy na server serializací informací v místně definované třídě pořadí do textu zprávy. Místně definovaná třída pořadí musí mít stejné schéma jako serverem definovaná třída pořadí, do které se aplikace na serveru pokusí deserializovat tělo zprávy. Nástroj XSD.exe umožňuje správci aplikace na serveru vytvořit a distribuovat schéma, které klient musí použít k serializaci zpráv, které budou chodit na server.

Když správce klientské aplikace obdrží schéma pro třídu order, nástroj XSD.exe se znovu použije ke generování třídy objednávky specifické pro klienta ze schématu. Je to tato třída, která se používá v následujícím příkladu klientského kódu, nikoli třída pořadí serveru (nástroj XSD.exe způsobuje, že třída generovaná schématem má stejný název jako původní třída). Tato nová třída objednávky slouží k serializaci objednávky do textu zprávy.

Následující příklad kódu je zpracování na straně klienta, slouží k serializaci objednávky a odeslání informací přidružených k objednávce do fronty. Kód přidruží informace o položkách, množství a adrese k prvkům schématu, které byly generovány pro třídu Order.cs nástrojem XSD.exe. Objednávka se odešle do fronty Orders v místním počítači.

#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

Po vygenerování schématu z třídy order na serveru můžete třídu upravit. Pokud se schéma nezmění, nemusíte ho redistribuovat. Po distribuci schématu a vygenerování třídy objednávky na straně klienta lze tuto třídu klienta také upravit nezávisle na třídě objednávky serveru, pokud se nezmění samotné schéma. Obě třídy jsou volně svázané.

Poznámky

Je XmlMessageFormatter výchozí formátovací modul, který instance MessageQueue používá k serializaci zpráv zapsaných do fronty. Když vytvoříte instanci objektu MessageQueue, vytvoří se pro vás instance objektu XmlMessageFormatter a přidružuje se k MessageQueue. Můžete zadat jiný formátovací prvek tak, že ho vytvoříte v kódu a přiřadíte ho Formatter vlastnosti .MessageQueue

Výchozí XmlMessageFormatter instance fronty se dá použít k zápisu do fronty, ale nedá se použít ke čtení z fronty, dokud nenastavíte TargetTypes vlastnost nebo TargetTypeNames u formátovače. Můžete buď nastavit jednu nebo obě tyto hodnoty na výchozí instanci formátovače, nebo můžete vytvořit novou instanci formátovače a nastavit hodnoty automaticky tak, že je předáte jako argumenty do příslušného XmlMessageFormatter konstruktoru.

Pokud zadáte TargetTypes místo TargetTypeNames, kontroluje se existence typu v době kompilace, nikoli v době čtení, což snižuje možnost chyby. TargetTypeNames vyžaduje, aby každý záznam byl plně kvalifikovaný a zadal název svého sestavení. Při práci s více souběžnými verzemi musí být navíc k názvu cílového typu připojeno také číslo verze.

Vlastnosti TargetTypeNames a TargetTypes sdělují formátovacímu modulu, jaká schémata se má při deserializaci zprávy pokusit shodovat. To umožňuje formátovacímu nástroji interpretovat text zprávy.

Instance serializovaná v těle zprávy musí vyhovovat jednomu ze schémat reprezentovaných v poli typu. Při čtení zprávy pomocí Receive metody vytvoří metoda objekt typu, který odpovídá identifikovanému schématu, a přečte do něj text zprávy.

Při čtení z fronty je potřeba nastavit pouze jednu z těchto dvou vlastností, ale můžete nastavit obě. Sada typů je kombinovaná sada ze dvou vlastností. Rozhodnutí o tom, kterou vlastnost použít, je specifické pro vaši aplikaci. Pokud text zprávy obsahuje typ, jehož schéma neodpovídá žádnému z typů v poli pro některou z vlastností, vyvolá se při čtení zprávy výjimka.

Je XmlMessageFormatter klíčovou součástí volně vázaného zasílání zpráv založených na jazyce XML. Nástroj XSD.exe používá formát XML se používá ke generování schématu XML, například při použití nástroje k serializaci třídy používané vaší aplikací. Třída musí mít konstruktor bez parametrů.

Formát se znovu použije v obráceném procesu, když nástroj vygeneruje třídu na základě schématu, které distribuujete k popisu dat třídy. Použití nástroje a schématu XML, které generuje, vám umožní vyhnout se redistributing.dll souborů pokaždé, když překompilujete třídu po změně implementace třídy. Dokud se schéma nezmění na klientovi nebo serveru, ostatní změny na obou stranách neovlivní druhou stranu.

Konstruktory

Vlastnosti

Metody

Platí pro

Viz také

• MessageQueue
• ActiveXMessageFormatter
• BinaryMessageFormatter
• IMessageFormatter