XmlMessageFormatter Klasse

Definition

Namespace:

System.Messaging

Assembly:

System.Messaging.dll

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

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

Vererbung

Object

XmlMessageFormatter

Implementiert

ICloneable IMessageFormatter

Beispiele

Das folgende Codebeispiel enthält drei Codeteile: eine Serverkomponente, eine Auftragsklasse und Clientcode. Die Bestellklasse kann vom dienstprogramm XSD.exe verwendet werden, um Schema zu generieren, das der Server innerhalb eingehender Nachrichten erkennt. Das Schema ist eine XML-formatierte Datei, die die Form der Klasse beschreibt. Dieses Schema kann dann auf der Clientseite verwendet werden, um eine clientspezifische Bestellklasse zu generieren, die dasselbe Schema wie die Serverklasse teilt.

Das folgende Codebeispiel stellt eine Serverkomponente dar, die Bestellungen über eine Nachrichtenwarteschlange empfängt. Der Textkörper der Nachricht sollte ein Order-Objekt sein, dessen Schema der unten aufgeführten Order.cs-Klasse entspricht. Der Serverprozess oder die Anwendung deserialisiert die Reihenfolge.

#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

Das folgende Codebeispiel stellt die Orderklasse dar, die ein Schema für die Reihenfolgeobjekte bereitstellt, die die Anwendung auf dem Server empfängt und deserialisiert.

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

Jede Clientanwendung, die mit der Anwendung auf dem Server interagiert, muss Nachrichten an den Server senden, indem Informationen in einer lokal definierten Reihenfolgeklasse in den Nachrichtentext serialisiert werden. Die lokal definierte Bestellklasse muss dasselbe Schema wie die serverdefinierte Bestellklasse aufweisen, in die die Anwendung auf dem Server versucht, den Nachrichtentext zu deserialisieren. Mit dem XSD.exe Hilfsprogramm kann der Manager der Anwendung auf dem Server das Schema erstellen und verteilen, das der Client verwenden muss, um Nachrichten zu serialisieren, die auf dem Server wechseln.

Wenn der Manager der Clientanwendung das Schema für die Bestellklasse empfängt, wird das XSD.exe Dienstprogramm erneut verwendet, um eine clientspezifische Bestellklasse aus dem Schema zu generieren. Es handelt sich um diese Klasse, die im folgenden Clientcodebeispiel verwendet wird, nicht die Bestellklasse des Servers (das dienstprogramm XSD.exe bewirkt, dass die schemagenerierte Klasse denselben Namen wie die ursprüngliche Klasse hat). Diese neue Bestellklasse wird verwendet, um die Reihenfolge in den Nachrichtentext zu serialisieren.

Das folgende Codebeispiel ist die clientseitige Verarbeitung, die verwendet wird, um eine Bestellung zu serialisieren und die Informationen zu senden, die der Reihenfolge in eine Warteschlange zugeordnet sind. Der Code verknüpft Element-, Mengen- und Adressinformationen mit Elementen des Schemas, die für die Order.cs-Klasse durch das XSD.exe Hilfsprogramm generiert wurden. Eine Bestellung wird an die Auftragswarteschlange auf dem lokalen Computer gesendet.

#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

Nachdem das Schema aus der Bestellklasse auf dem Server generiert wurde, können Sie die Klasse ändern. Wenn sich das Schema nicht ändert, müssen Sie das Schema nicht neu verteilen. Nachdem Sie das Schema verteilt und eine clientseitige Bestellklasse generiert haben, kann diese Clientklasse auch unabhängig von der Bestellklasse des Servers geändert werden, solange das Schema selbst nicht geändert wird. Die beiden Klassen sind lose gekoppelt.

Hinweise

Der XmlMessageFormatter Standardformatierer ist der Standardformatierer, in dem eine Instanz MessageQueue verwendet wird, um Nachrichten zu serialisieren, die in die Warteschlange geschrieben wurden. Beim Erstellen einer Instanz von , wird eine Instanz XmlMessageFormatter von MessageQueuefür Sie erstellt und der zugeordnetMessageQueue. Sie können einen anderen Formatierer angeben, indem Sie sie in Ihrem Code erstellen und der Formatter Eigenschaft Ihrer MessageQueue.

Die Standardinstanz XmlMessageFormatter einer Warteschlange kann verwendet werden, um in die Warteschlange zu schreiben, kann aber nicht verwendet werden, um aus der Warteschlange zu lesen, bis Sie entweder die Eigenschaft oder TargetTypeNames die TargetTypes Eigenschaft im Formatierer festlegen. Sie können entweder eine oder beide dieser Werte für die Standardformatierinstanz festlegen, oder Sie können eine neue Instanz des Formatierers erstellen und die Werte automatisch festlegen, indem Sie sie als Argumente an den entsprechenden XmlMessageFormatter Konstruktor übergeben.

Wenn Sie TargetTypes TargetTypeNamesanstelle von ", "Typexistenz" zur Kompilierungszeit und nicht zur Lesezeit überprüfen, wird die Möglichkeit für Fehler reduziert. TargetTypeNames erfordert, dass jeder Eintrag vollständig qualifiziert ist und seinen Assemblynamen angibt. Darüber hinaus muss bei der Arbeit mit mehreren gleichzeitigen Versionen auch die Versionsnummer an den Zieltypnamen angefügt werden.

Die TargetTypeNames Eigenschaften TargetTypes teilen dem Formatierer mit, welche Schemas beim Deserialisieren einer Nachricht übereinstimmen sollen. Dadurch kann der Formatierer den Nachrichtentext interpretieren.

Die im Nachrichtentext serialisierte Instanz muss einem der schemas entsprechen, die im Typarray dargestellt sind. Wenn Sie die Nachricht mithilfe der Receive Methode lesen, erstellt die Methode ein Objekt des Typs, das dem identifizierten Schema entspricht, und liest den Nachrichtentext darin vor.

Beim Lesen aus der Warteschlange müssen nur eine der beiden Eigenschaften festgelegt werden, sie können aber beide festlegen. Der Satz von Typen ist der kombinierte Satz aus den beiden Eigenschaften. Die Entscheidung, welche Eigenschaft für Ihre Anwendung verwendet werden soll, ist spezifisch. Wenn der Nachrichtentext einen Typ enthält, dessen Schema keinem der Typen im Array für beide Eigenschaften entspricht, wird eine Ausnahme ausgelöst, wenn die Nachricht gelesen wird.

Dies XmlMessageFormatter ist eine wichtige Komponente der lose gekoppelten XML-basierten Messaging-Nachrichten. Das hilfsprogramm XSD.exe verwendet das XML-Format, um XML-Schema zu generieren, z. B. wenn Sie das Hilfsprogramm verwenden, um eine klasse zu serialisieren, die von Ihrer Anwendung verwendet wird. Die Klasse muss einen parameterlosen Konstruktor haben.

Das Format wird erneut im Umgekehrten Prozess verwendet, wenn das Dienstprogramm eine Klasse basierend auf dem Schema generiert, das Sie verteilen, um Die Klassendaten zu beschreiben. Die Verwendung des Hilfsprogramms und des generierten XML-Schemas ermöglicht es Ihnen, redistributing.dll Dateien jedes Mal zu vermeiden, wenn Sie eine Klasse neu kompilieren, nachdem die Implementierung Ihrer Klasse geändert wurde. Solange sich das Schema nicht auf dem Client oder dem Server ändert, wirken sich andere Änderungen auf beiden Seiten nicht auf die andere aus.

Konstruktoren

XmlMessageFormatter()	Initialisiert eine neue Instanz der XmlMessageFormatter-Klasse ohne Angabe einer Gruppe von Zieltypen.
XmlMessageFormatter(String[])	Initialisiert eine neue Instanz der XmlMessageFormatter-Klasse und legt die übergebenen Zieltypen als ein Array von (voll gekennzeichneten) Zeichenfolgenwerten fest.
XmlMessageFormatter(Type[])	Initialisiert eine neue Instanz der XmlMessageFormatter-Klasse und legt die übergebenen Zieltypen als ein Array von Objekttypen fest.

Eigenschaften

TargetTypeNames	Gibt die Gruppe der möglichen Typen an, die vom Formatierungsprogramm aus der bereitgestellten Meldung deserialisiert werden können.
TargetTypes	Gibt die Gruppe der möglichen Typen an, die vom Formatierungsprogramm aus der bereitgestellten Meldung deserialisiert werden können.

Methoden

CanRead(Message)	Ermittelt, ob das Formatierprogramm die Meldung deserialisieren kann.
Clone()	Erstellt eine Instanz der XmlMessageFormatter-Klasse, das dieselben Lese-/Schreibeigenschaften (die Gruppe von Zieltypen) besitzt wie die aktuelle XmlMessageFormatter-Instanz.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
Read(Message)	Liest den Inhalt aus der angegebenen Meldung und erstellt ein Objekt, das die deserialisierte Meldung enthält.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
Write(Message, Object)	Serialisiert ein Objekt in den Textkörper der Meldung.

Siehe auch

• MessageQueue
• ActiveXMessageFormatter
• BinaryMessageFormatter
• IMessageFormatter