XmlMessageFormatter Klasse

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

Vererbung

Object

XmlMessageFormatter

Implementiert

ICloneable IMessageFormatter

Beispiele

Das folgende Codebeispiel enthält drei Codeelemente: eine Serverkomponente, eine Order-Klasse und Clientcode. Die Order-Klasse kann vom Hilfsprogramm XSD.exe verwendet werden, um ein Schema zu generieren, das der Server in eingehenden Nachrichten erkennt. Das Schema ist eine XML-formatierte Datei, die die "Form" der Klasse beschreibt. Dieses Schema kann dann clientseitig verwendet werden, um eine clientspezifische Orderklasse zu generieren, die das gleiche Schema wie die Serverklasse verwendet.

Das folgende Codebeispiel stellt eine Serverkomponente dar, die Bestellungen über eine Nachrichtenwarteschlange empfängt. Der Nachrichtentext sollte ein Order-Objekt sein, dessen Schema mit der Order.cs Klasse unten übereinstimmt. 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 Order-Klasse dar, die ein Schema für die Order-Objekte 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 Reihenfolgenklasse in den Nachrichtentext serialisiert werden. Die lokal definierte Orderklasse muss das gleiche Schema wie die serverdefinierte Orderklasse aufweisen, in der die Anwendung auf dem Server versucht, den Nachrichtentext zu deserialisieren. Das Hilfsprogramm XSD.exe ermöglicht es dem Manager der Anwendung auf dem Server, das Schema zu erstellen und zu verteilen, das der Client zum Serialisieren von Nachrichten verwenden muss, die an den Server gesendet werden.

Wenn der Manager der Clientanwendung das Schema für die Order-Klasse empfängt, wird das Hilfsprogramm XSD.exe erneut verwendet, um eine clientspezifische Orderklasse aus dem Schema zu generieren. Es ist diese Klasse, die im folgenden Clientcodebeispiel verwendet wird, nicht die Order-Klasse des Servers (das hilfsprogramm XSD.exe bewirkt, dass die vom Schema generierte Klasse den gleichen Namen wie die ursprüngliche Klasse hat). Diese neue Orderklasse 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 der Bestellung zugeordneten Informationen an eine Warteschlange zu senden. Der Code ordnet Element-, Mengen- und Adressinformationen Elementen des Schemas zu, die vom Hilfsprogramm XSD.exe für die Order.cs-Klasse generiert wurden. Eine Bestellung wird an die Orders-Warteschlange 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 Order-Klasse 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 Order-Klasse generiert haben, kann diese Clientklasse auch unabhängig von der Auftragsklasse des Servers geändert werden, solange das Schema selbst nicht geändert wird. Die beiden Klassen sind lose miteinander verbunden.

Hinweise

Ist XmlMessageFormatter der Standardformatierer, den ein instance von MessageQueue verwendet, um in die Warteschlange geschriebene Nachrichten zu serialisieren. Wenn Sie eine instance von MessageQueueerstellen, wird eine instance von XmlMessageFormatter erstellt und der MessageQueuezugeordnet. Sie können einen anderen Formatierer angeben, indem Sie ihn in Ihrem Code erstellen und der Formatter -Eigenschaft von MessageQueuezuweisen.

Die Standard-instance XmlMessageFormatter einer Warteschlange kann zum Schreiben in die Warteschlange verwendet werden, kann jedoch erst dann zum Lesen aus der Warteschlange verwendet werden, wenn Sie die TargetTypes - oder TargetTypeNames -Eigenschaft im Formatierer festgelegt haben. Sie können entweder einen oder beide dieser Werte im Standardformatierer instance festlegen, oder Sie können eine neue instance des Formatierers erstellen und die Werte automatisch festlegen, indem Sie sie als Argumente an den entsprechenden XmlMessageFormatter Konstruktor übergeben.

Wenn Anstelle von TargetTypeNamesangegeben TargetTypes wird, wird die Typexistenz zur Kompilierzeit statt zur Lesezeit überprüft, wodurch die Fehlergeminderbarkeit verringert wird. TargetTypeNames erfordert, dass jeder Eintrag voll qualifiziert ist, wobei der Assemblyname angegeben wird. Darüber hinaus muss bei der Arbeit mit mehreren gleichzeitigen Versionen auch die Versionsnummer an den Namen des Zieltyps angefügt werden.

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

Die im Nachrichtentext serialisierte instance muss einem der Schemas entsprechen, die im Typarray dargestellt werden. Wenn Sie die Nachricht mit der Receive -Methode lesen, erstellt die -Methode ein Objekt des Typs, der dem identifizierten Schema entspricht, und liest den Nachrichtentext darin ein.

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

Ist XmlMessageFormatter eine wichtige Komponente für lose gekoppeltes XML-basiertes Messaging. Das Hilfsprogramm XSD.exe verwendet das XML-Format, das zum Generieren eines XML-Schemas verwendet wird, 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 im umgekehrten Prozess erneut verwendet, wenn das Hilfsprogramm eine Klasse basierend auf dem Schema generiert, das Sie verteilen, um Ihre 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 auf dem Client oder server nicht ändert, wirken sich andere Änderungen auf beiden Seiten nicht auf die andere aus.

Konstruktoren

Eigenschaften

Methoden

Gilt für:

Weitere Informationen

• MessageQueue
• ActiveXMessageFormatter
• BinaryMessageFormatter
• IMessageFormatter