XmlMessageFormatter-Klasse

Serialisiert und deserialisiert mithilfe des auf XSD (XML Schema Definition) beruhenden XML-Formats Objekte in den oder aus dem Textkörper einer Meldung.

Namespace: System.Messaging
Assembly: System.Messaging (in system.messaging.dll)

Syntax

'Declaration
Public Class XmlMessageFormatter
    Implements IMessageFormatter, ICloneable
'Usage
Dim instance As XmlMessageFormatter

public class XmlMessageFormatter : IMessageFormatter, ICloneable

public ref class XmlMessageFormatter : IMessageFormatter, ICloneable

public class XmlMessageFormatter implements IMessageFormatter, ICloneable

public class XmlMessageFormatter implements IMessageFormatter, ICloneable

Hinweise

Der XmlMessageFormatter ist das Standardformatierungsprogramm, das von einer Instanz von MessageQueue zum Serialisieren von Meldungen verwendet wird, die in die Warteschlange geschrieben werden. Beim Erstellen einer Instanz von MessageQueue wird automatisch eine Instanz von XmlMessageFormatter erstellt und der MessageQueue zugordnet. Sie können ein anderes Formatierungsprogramm angeben, indem Sie es im Programmcode erstellen und der Formatter-Eigenschaft der MessageQueue zuweisen.

Die XmlMessageFormatter-Standardinstanz kann zum Schreiben in die Warteschlange verwendet werden. Zum Lesen aus der Warteschlange kann sie allerdings nur dann verwendet werden, wenn die TargetTypes-Eigenschaft oder die TargetTypeNames-Eigenschaft des Formatierungsprogramms festgelegt wurde. Sie können einen oder beide Werte für die Standardinstanz des Formatierungsprogramms festlegen, oder Sie können eine neue Instanz des Formatierungsprogramms erstellen und die Werte automatisch festlegen, indem Sie sie als Argumente an den entsprechenden XmlMessageFormatter-Konstruktor übergeben.

Wenn Sie anstelle der TargetTypeNames-Eigenschaft die TargetTypes-Eigenschaft angeben, wird zur Kompilierzeit und nicht zur Lesezeit auf das Vorhandensein von Typen geprüft und somit die Fehlerwahrscheinlichkeit minimiert. Für TargetTypeNames muss jeder Eintrag voll gekennzeichnet sein und der zugehörige Assemblyname angegeben werden. Darüber hinaus muss bei der gleichzeitigen Verwendung mehrerer Versionen auch die Versionsnummer an den Namen des Zieltyps angefügt werden.

Sowohl durch die TargetTypeNames-Eigenschaft als auch die TargetTypes-Eigenschaft wird dem Formatierungsprogramm mitgeteilt, welche Schemas beim Deserialisieren einer Meldung auf Übereinstimmung geprüft werden sollen. Dies ermöglicht dem Formatierungsprogramm die Interpretation des Meldungstextes.

Die im Meldungstext serialisierte Instanz muss einem der im Typarray dargestellten Schemas entsprechen. Wenn Sie die Meldung mit der Receive-Methode lesen, erstellt die Methode ein Objekt des Typs, der dem bezeichneten Schema entspricht, und liest den Meldungstext in dieses Objekt.

Zum Lesen aus der Warteschlange muss nur eine der beiden Eigenschaften festgelegt werden, es können jedoch auch beide festgelegt werden. Die Typengruppe setzt sich aus Typen beider Eigenschaften zusammen. Die verwendete Eigenschaft hängt von Ihrer Anwendung ab. Wenn der Meldungstext einen Typ enthält, dessen Schema mit keinem der Typen im Array einer der Eigenschaften übereinstimmt, wird beim Lesen der Meldung eine Ausnahme ausgelöst.

Der XmlMessageFormatter ist eine entscheidende Komponente beim lose verknüpften XML-Messaging. Das Dienstprogramm XSD.exe verwendet das XML-Format und kann ein XML-Schema generieren, z. B. wenn Sie mit dem Dienstprogramm eine von der Anwendung verwendete Klasse serialisieren. Die Klasse muss über einen Standardkonstruktor verfügen.

Das Format wird erneut beim umgekehrten Vorgang verwendet, wenn das Dienstprogramm eine Klasse generiert, die auf dem Schema aufbaut, das Sie zur Beschreibung der Klassendaten bereitstellen. Mit der Verwendung des Dienstprogramms und dem von diesem generierten XML-Schema entfällt die Notwendigkeit, nach jeder Neukompilierung einer Klasse aufgrund einer Implementierungsänderung DLL-Dateien neu zu verteilen. Solange das Schema sich weder auf dem Client noch auf dem Server ändert, haben andere Änderungen auf einer Seite keine Auswirkungen auf die andere.

Beispiel

Das folgende Codebeispiel enthält drei Codeteile: eine Serverkomponente, eine Orderklasse und Clientcode. Mithilfe der Order-Klasse kann das Dienstprogramm XSD.exe ein Schema generieren, das der Server in eintreffenden Meldungen erkennt. Das Schema ist eine Datei im XML-Format, die die "Form" der Klasse beschreibt. Dieses Schema kann dann auf der Clientseite zum Generieren einer clientspezifischen Order-Klasse verwendet werden, die dasselbe Schema wie die Serverklasse verwendet.

Im folgenden Codebeispiel wird eine Serverkomponente dargestellt, die Orders über eine Meldungswarteschlange erhält. Der Textkörper der Meldung muss ein Order-Objekt sein, dessen Schema mit der unten beschriebenen Klasse Order.cs übereinstimmt. Der Serverprozess oder die Serveranwendung deserialisiert die Bestellung.

Imports System
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 'Main
    
    
    ' 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 'EnsureQueueExists
End Class 'Server

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);
         }
     }
 }

#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();
   }
}

import System.*;
import System.Messaging.*;

public class Server
{
    public static void main(String[] args)
    {
        Console.WriteLine("Processing Orders");

        String queuePath = ".\\orders";
        EnsureQueueExists(queuePath);
        MessageQueue queue = new MessageQueue(queuePath);
        ((XmlMessageFormatter)queue.get_Formatter()).
            set_TargetTypeNames(new String[] { "Order" });

        while (true) {
            Order newOrder = (Order)queue.Receive().get_Body();
            newOrder.ShipItems();
        }
    } //main

    // Creates the queue if it does not already exist.
    public static void EnsureQueueExists(String path)
    {
        if (!(MessageQueue.Exists(path))) {
            MessageQueue.Create(path);
        }
    } //EnsureQueueExists
} //Server

Im folgenden Codebeispiel wird die Order-Klasse dargestellt, die ein Schema für die Order-Objekte bereitstellt, die von der Anwendung auf dem Server empfangen und deserialisiert werden:

Imports System
Imports Microsoft.VisualBasic

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 'ShipItems 
End Class 'Order 

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. */
 
     }
 }

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. */
   }

};

import 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}", System.Convert.ToString(itemId));
        Console.WriteLine("\tQuantity : {0}", System.Convert.ToString(quantity));
        Console.WriteLine("\tShip To  : {0}", System.Convert.ToString(address));
        // Add order to the database.
        /* Insert code here. */
    } //ShipItems 
} //Order 

Jede Clientanwendung, die mit der Anwendung auf dem Server kommuniziert, muss Meldungen an den Server senden und zu diesem Zweck Informationen aus einer lokal definierten Order-Klasse in den Textkörper der Meldung serialisieren. Die lokal definierte Order-Klasse muss dasselbe Schema besitzen wie die auf dem Server definierte Order-Klasse, in die die Anwendung auf dem Server den Textkörper der Meldung deserialisiert. Der Manager der Anwendung auf dem Server kann mit dem Dienstprogramm XSD.exe das Schema erstellen und bereitstellen, das der Client zum Serialisieren von Meldungen an den Server verwenden soll.

Wenn der Manager der Clientanwendung das Schema für die Order-Klasse erhält, wird das Dienstprogramm XSD.exe erneut verwendet, um eine clientspezifische Order-Klasse aus den Schema zu generieren. Im folgenden Clientcodebeispiel wird diese Order-Klasse verwendet, jedoch nicht die Order-Klasse des Servers. (Das Dienstprogramm XSD.exe vergibt für die vom Schema generierte Klasse denselben Namen, den die ursprüngliche Klasse trägt.) Diese neue Order-Klasse wird zum Serialisieren der Bestellung in den Textkörper der Meldung verwendet.

Im folgenden Codebeispiel wird die clientseitige Verarbeitung dargestellt, d. h. die Serialisierung einer Order und das Senden zugehörigen Informationen an die Warteschlage. Im Codebeispiel werden Item-, Quantity- und Address-Daten Elementen des Schemas zugeordnet, die vom Dienstprogramm XSD.exe für die Klasse Order.cs generiert wurden. An die Warteschlange Orders auf dem lokalen Computer wird eine Order gesendet.

Imports System
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 'Main
    
    ' 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 'EnsureQueueExists
End Class 'Client 

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);
         }
     }
 
 }

#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();
}

import System.*;
import System.Messaging.*;

class Client
{
    public static void main(String args[])
    {
        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();
    } //main

    // Creates the queue if it does not already exist.
    public static void EnsureQueueExists(String path)
    {
        if (!(MessageQueue.Exists(path))) {
            MessageQueue.Create(path);
        }
    } //EnsureQueueExists
} //Client

Nachdem das Schema aus der Order-Klasse des Servers generiert wurde, kann die Klasse verändert werden. Solange sich das Schema nicht ändert, muss es nicht erneut bereitgestellt werden. Nachdem das Schema bereitgestellt und eine Order-Klasse auf Clienstseite generiert wurde, kann diese Clientklasse ebenfalls unabhängig von der Order-Klasse des Servers verändert werden, solange das Schema selbst nicht verändert wird. Die beiden Klassen sind jetzt lose verknüpft.

Vererbungshierarchie

System.Object
  System.Messaging.XmlMessageFormatter

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0

Siehe auch

Referenz

XmlMessageFormatter-Member
System.Messaging-Namespace
MessageQueue-Klasse
ActiveXMessageFormatter-Klasse
BinaryMessageFormatter-Klasse
IMessageFormatter-Schnittstelle