XmlMessageFormatter Třída

Reference

Definice

Obor názvů:: System.Messaging

Sestavení:: System.Messaging.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Serializuje a deserializuje objekty do nebo z textu zprávy pomocí formátu XML založeného na definici schématu 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

Dědičnost: Object
XmlMessageFormatter

Implementuje: ICloneable IMessageFormatter

Příklady

Následující příklad kódu obsahuje tři části kódu: serverovou komponentu, třídu objednávky a klientský kód. Třídu order může nástroj XSD.exe použít ke generování schématu, které server rozpozná v příchozích zprávách. Schéma je formátovaný soubor XML, který popisuje "obrazec" třídy. Toto schéma pak lze použít na straně klienta k vygenerová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 order, jehož schéma odpovídá následující třídě Order.cs. 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 objekty order, které aplikace na serveru přijímá 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 objednávky 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 na server chodit.

Když správce klientské aplikace obdrží schéma pro třídu order, nástroj XSD.exe se znovu použije k vygenerová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 v třídě pořadí serveru (nástroj XSD.exe způsobí, že třída vygenerovaná schématem bude mít stejný název jako původní třída). Tato nová třída objednávky se používá k serializaci objednávky do textu zprávy.

Následující příklad kódu je zpracování na straně klienta, které 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žce, 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 na 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 znovu distribuovat. Po distribuci schématu a vygenerování třídy objednávky na straně klienta může být tato klientská třída také změněna nezávisle na třídě objednávky serveru, pokud samotné schéma není změněno. Tyto dvě třídy se volně snoubí.

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 MessageQueuenástroje , vytvoří se pro vás instance objektu XmlMessageFormatter a přidružuje se k objektu MessageQueue. Jiný formátovací modul můžete zadat tak, že ho vytvoříte v kódu a přiřadíte ho Formatter vlastnosti .MessageQueue

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

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

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 textu zprávy musí být v souladu s jedním ze schémat reprezentovaných v poli typů. Při čtení zprávy pomocí Receive metody metoda vytvoří 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 jenom jednu z těchto dvou vlastností, ale můžete nastavit obě vlastnosti. 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ě svázaných zpráv založených na 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, umožňuje vyhnout se redistributing.dll souborů pokaždé, když překompilujete třídu po implementaci vaší třídy se změnila. Dokud se schéma na klientovi nebo serveru nezmění, ostatní změny na obou stranách neovlivní druhou stranu.

Konstruktory

XmlMessageFormatter()	Inicializuje novou instanci XmlMessageFormatter třídy bez nastavení cílových typů.
XmlMessageFormatter(String[])	Inicializuje novou instanci XmlMessageFormatter třídy a nastaví cílové typy předávané jako pole (plně kvalifikovaných) řetězcových hodnot.
XmlMessageFormatter(Type[])	Inicializuje novou instanci XmlMessageFormatter třídy a nastaví cílové typy předávané jako pole typů objektů.

Vlastnosti

TargetTypeNames	Určuje sadu možných typů, které budou deserializovány formátovacím nástrojem z poskytnuté zprávy.
TargetTypes	Určuje sadu možných typů, které budou deserializovány formátovacím nástrojem z poskytnuté zprávy.

Metody

CanRead(Message)	Určuje, zda formátovací modul může zprávu deserializovat.
Clone()	Vytvoří instanci XmlMessageFormatter třídy, jejíž vlastnosti pro čtení a zápis (sady cílových typů) jsou stejné jako aktuální XmlMessageFormatter instance.
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetType()	Získá aktuální Type instanci. (Zděděno od Object)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
Read(Message)	Přečte obsah z dané zprávy a vytvoří objekt, který obsahuje deserializovanou zprávu.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
Write(Message, Object)	Serializuje objekt do textu zprávy.

Platí pro