XmlMessageFormatter Klasse

Definition

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Serialisiert und deserialisiert Objekte mithilfe des XML-Formats basierend auf der XSD-Schemadefinition in oder aus dem Textkörper einer Nachricht.

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 Order-Klasse kann vom hilfsprogramm XSD.exe verwendet werden, um schema zu generieren, das der Server innerhalb eingehender Nachrichten erkennt. Das Schema ist eine XML-formatierte Datei, die das "Shape" der Klasse beschreibt. Dieses Schema kann dann auf clientseitiger Seite verwendet werden, um eine clientspezifische Bestellklasse zu generieren, die dasselbe Schema wie die Serverklasse verwendet.

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 folgenden 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 Bestellobjekte 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 deserialisieren. Das hilfsprogramm XSD.exe ermöglicht dem Manager der Anwendung auf dem Server das Erstellen und Verteilen des Schemas, das der Client zum Serialisieren von Nachrichten auf dem Server verwenden muss.

Wenn der Manager der Clientanwendung das Schema für die Auftragsklasse empfängt, wird das XSD.exe Hilfsprogramm erneut verwendet, um eine clientspezifische Auftragsklasse aus dem Schema zu generieren. Dies ist diese Klasse, die im folgenden Clientcodebeispiel verwendet wird, nicht die Bestellklasse des Servers (das hilfsprogramm XSD.exe bewirkt, dass die vom Schema generierte 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 zugeordnet sind, an eine Warteschlange. Der Code ordnet Element-, Mengen- und Adressinformationen Elementen des Schemas zu, die für die Order.cs Klasse durch das Hilfsprogramm XSD.exe generiert wurden. Auf dem lokalen Computer wird eine Bestellung an die Warteschlange "Bestellungen" 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 Auftragsklasse auf dem Server generiert wurde, können Sie die Klasse ändern. Sofern 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 Auftragsklasse des Servers geändert werden, solange das Schema selbst nicht geändert wird. Die beiden Klassen sind lose gekoppelt.

Hinweise

Dies XmlMessageFormatter ist der Standardformatierer, der von einer Instanz zum Serialisieren von MessageQueue Nachrichten verwendet wird, die in die Warteschlange geschrieben wurden. Wenn Sie eine Instanz erstellen MessageQueue, wird eine Instanz von XmlMessageFormatter für Sie erstellt und der MessageQueuezugeordnet. Sie können einen anderen Formatierer angeben, indem Sie ihn in Ihrem Code erstellen und sie der Formatter Eigenschaft Ihrer MessageQueuezuweisen.

Die Standardinstanz XmlMessageFormatter einer Warteschlange kann verwendet werden, um in die Warteschlange zu schreiben, aber sie kann nicht zum Lesen aus der Warteschlange verwendet werden, bis Sie die Eigenschaft oder TargetTypeNames die TargetTypes Eigenschaft für den Formatierer festgelegt haben. Sie können entweder einen 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.

Beim Angeben TargetTypes anstelle TargetTypeNamesvon "Typexistenz" wird die Kompilierungszeit anstelle der Lesezeit überprüft, wodurch die Fehlermöglichkeit reduziert wird. TargetTypeNames erfordert, dass jeder Eintrag vollqualifizierter 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.

Mit TargetTypeNames den Eigenschaften wird TargetTypes dem Formatierer mitgeteilt, welche Schemas beim Deserialisieren einer Nachricht übereinstimmen sollen. Dadurch kann der Formatierer den Nachrichtentext interpretieren.

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

Beim Lesen aus der Warteschlange muss nur eine der beiden Eigenschaften festgelegt werden, sie können jedoch beides festlegen. Der Satz von Typen ist der kombinierte Satz aus den beiden Eigenschaften. Die Entscheidung, welche Eigenschaft verwendet werden soll, ist für Ihre Anwendung spezifisch. 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.

Dies ist eine wichtige Komponente für lose gekoppelte XML-basierte Messaging.The XmlMessageFormatter is a crucial component of losely coupled XML-based messaging. Das hilfsprogramm XSD.exe verwendet das XML-Format zum Generieren von XML-Schemas, z. B. wenn Sie das Hilfsprogramm verwenden, um eine von Der Anwendung verwendete Klasse zu serialisieren. Die Klasse muss einen parameterlosen Konstruktor haben.

Das Format wird erneut im umgekehrten Prozess verwendet, wenn das Hilfsprogramm 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 sich die Implementierung Der Klasse geändert hat. 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

Name	Beschreibung
XmlMessageFormatter()	Initialisiert eine neue Instanz der XmlMessageFormatter Klasse, ohne dass Zieltypen festgelegt sind.
XmlMessageFormatter(String[])	Initialisiert eine neue Instanz der XmlMessageFormatter Klasse, wobei das Festlegen von Zieltypen, die als Array von (vollqualifizierten) Zeichenfolgenwerten übergeben werden.
XmlMessageFormatter(Type[])	Initialisiert eine neue Instanz der XmlMessageFormatter Klasse, wobei Zieltypen festgelegt werden, die als Array von Objekttypen übergeben werden.

Eigenschaften

Name	Beschreibung
TargetTypeNames	Gibt den Satz möglicher Typen an, die vom Formatierer der bereitgestellten Nachricht deserialisiert werden.
TargetTypes	Gibt den Satz möglicher Typen an, die vom Formatierer der bereitgestellten Nachricht deserialisiert werden.

Methoden

Name	Beschreibung
CanRead(Message)	Bestimmt, ob der Formatierer die Nachricht deserialisieren kann.
Clone()	Erstellt eine Instanz der XmlMessageFormatter Klasse, deren Lese-/Schreibeigenschaften (die Gruppen von Zieltypen) mit der aktuellen XmlMessageFormatter Instanz identisch sind.
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
Read(Message)	Liest den Inhalt aus der angegebenen Nachricht und erstellt ein Objekt, das die deserialisierte Nachricht 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 Nachricht.

Gilt für:

Weitere Informationen

Feedback

War diese Seite hilfreich?