XmlMessageFormatter Klasa

Odwołanie

Definicja

Przestrzeń nazw:: System.Messaging

Zestaw:: System.Messaging.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Serializuje i deserializuje obiekty do lub z treści komunikatu przy użyciu formatu XML opartego na definicji schematu 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

Dziedziczenie: Object
XmlMessageFormatter

Implementuje: ICloneable IMessageFormatter

Przykłady

Poniższy przykład kodu zawiera trzy elementy kodu: składnik serwera, klasę zamówienia i kod klienta. Klasa order może być używana przez narzędzie XSD.exe do generowania schematu rozpoznawany przez serwer w komunikatach przychodzących. Schemat jest plikiem w formacie XML, który opisuje "kształt" klasy. Tego schematu można następnie użyć po stronie klienta do wygenerowania klasy zamówienia specyficznej dla klienta, która współużytkuje ten sam schemat co klasa serwera.

Poniższy przykład kodu reprezentuje składnik serwera, który odbiera zamówienia za pośrednictwem kolejki komunikatów. Treść komunikatu powinna być obiektem kolejności, którego schemat odpowiada poniższej klasie Order.cs. Proces serwera lub aplikacja deserializuje kolejność.

#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

Poniższy przykład kodu reprezentuje klasę order, która udostępnia schemat obiektów zamówień, które aplikacja na serwerze odbiera i 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żda aplikacja kliencka, która współdziała z aplikacją na serwerze, musi wysyłać komunikaty do serwera, serializując informacje w lokalnie zdefiniowanej klasie kolejności do treści komunikatu. Klasa kolejności zdefiniowanej lokalnie musi mieć ten sam schemat co klasa kolejności zdefiniowanej przez serwer, w której aplikacja na serwerze podejmie próbę deserializacji treści komunikatu. Narzędzie XSD.exe umożliwia menedżerowi aplikacji na serwerze tworzenie i dystrybuowanie schematu, który klient musi używać do serializacji komunikatów przechodzących do serwera.

Gdy menedżer aplikacji klienckiej odbiera schemat dla klasy order, narzędzie XSD.exe jest ponownie używane do generowania klasy zamówienia specyficznej dla klienta na podstawie schematu. Jest to klasa używana w poniższym przykładzie kodu klienta, a nie w klasie order serwera (narzędzie XSD.exe powoduje, że klasa wygenerowana przez schemat ma taką samą nazwę jak oryginalna klasa). Ta nowa klasa kolejności służy do serializacji kolejności w treści komunikatu.

Poniższy przykład kodu to przetwarzanie po stronie klienta używane do serializacji zamówienia i wysyłanie informacji skojarzonych z zamówieniem do kolejki. Kod kojarzy informacje o elemencie Item, Quantity i Address z elementami schematu, które zostały wygenerowane dla klasy Order.cs przez narzędzie XSD.exe. Zamówienie jest wysyłane do kolejki Zamówienia na komputerze lokalnym.

#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 wygenerowaniu schematu z klasy order na serwerze można zmodyfikować klasę. O ile schemat nie ulegnie zmianie, nie trzeba ponownie dystrybuować schematu. Po rozproszeniu schematu i wygenerowaniu klasy zamówienia po stronie klienta można również zmodyfikować tę klasę klienta niezależnie od klasy order serwera, o ile sam schemat nie zostanie zmodyfikowany. Obie klasy stały się luźno powiązane.

Uwagi

Jest XmlMessageFormatter domyślnym formaterem używanym przez wystąpienie programu do serializacji komunikatów MessageQueue zapisywanych w kolejce. Podczas tworzenia wystąpienia MessageQueue XmlMessageFormatter klasy wystąpienie klasy jest tworzone dla Ciebie i skojarzone z programem MessageQueue. Możesz określić inny formater, tworząc go w kodzie i przypisując go do Formatter właściwości .MessageQueue

Domyślne XmlMessageFormatter wystąpienie kolejki może służyć do zapisywania w kolejce, ale nie można jej użyć do odczytu z kolejki, dopóki nie ustawisz TargetTypes właściwości lub TargetTypeNames w obiekcie formatujący. Można ustawić jedną lub obie te wartości w domyślnym wystąpieniu formatatora lub utworzyć nowe wystąpienie formatatora i ustawić wartości automatycznie, przekazując je jako argumenty do odpowiedniego XmlMessageFormatter konstruktora.

Podczas określania TargetTypes zamiast TargetTypeNames, obecność typu jest sprawdzana w czasie kompilacji, a nie w czasie odczytu, co zmniejsza prawdopodobieństwo wystąpienia błędu. TargetTypeNames wymaga, aby każdy wpis był w pełni kwalifikowany, określając jego nazwę zestawu. Ponadto podczas pracy z wieloma współbieżnymi wersjami należy również dołączyć numer wersji do nazwy typu docelowego.

Właściwości TargetTypeNames i TargetTypes informują obiekt formatujący, jakie schematy mają być zgodne podczas deserializacji komunikatu. Dzięki temu program formatujący może interpretować treść komunikatu.

Wystąpienie serializowane w treści komunikatu musi być zgodne z jednym ze schematów reprezentowanych w tablicy typów. Podczas odczytywania komunikatu Receive przy użyciu metody metoda tworzy obiekt typu, który odpowiada zidentyfikowanemu schematowi i odczytuje do niego treść komunikatu.

Podczas odczytywania z kolejki należy ustawić tylko jedną z dwóch właściwości, ale można ustawić obie te właściwości. Zestaw typów jest zestawem połączonym z dwóch właściwości. Decyzja o tym, która właściwość ma być używana, jest specyficzna dla twojej aplikacji. Jeśli treść komunikatu zawiera typ, którego schemat nie pasuje do żadnego z typów w tablicy dla dowolnej właściwości, podczas odczytywania komunikatu zostanie zgłoszony wyjątek.

Jest XmlMessageFormatter to kluczowy składnik luźno powiązanych komunikatów opartych na kodzie XML. Narzędzie XSD.exe używa formatu XML do generowania schematu XML, takiego jak użycie narzędzia do serializacji klasy używanej przez aplikację. Klasa musi mieć konstruktor bez parametrów.

Format jest ponownie używany w procesie odwrotnym, gdy narzędzie generuje klasę na podstawie schematu dystrybuowanego w celu opisania danych klasy. Użycie narzędzia i schematu XML, które generuje, pozwala uniknąć redistributing.dll plików za każdym razem, gdy ponownie skompilujesz klasę po zmianie implementacji klasy. Tak długo, jak schemat nie zmienia się na kliencie lub serwerze, inne zmiany po obu stronach nie mają wpływu na drugą.

Konstruktory

XmlMessageFormatter()	Inicjuje XmlMessageFormatter nowe wystąpienie klasy bez ustawionych typów docelowych.
XmlMessageFormatter(String[])	Inicjuje XmlMessageFormatter nowe wystąpienie klasy, ustawiając typy docelowe przekazywane jako tablicę (w pełni kwalifikowanych) wartości ciągów.
XmlMessageFormatter(Type[])	Inicjuje XmlMessageFormatter nowe wystąpienie klasy, ustawiając typy docelowe przekazywane jako tablicę typów obiektów.

Właściwości

TargetTypeNames	Określa zestaw możliwych typów, które zostaną zdeserializowane przez program formatujący z dostarczonego komunikatu.
TargetTypes	Określa zestaw możliwych typów, które zostaną zdeserializowane przez program formatujący z dostarczonego komunikatu.

Metody

CanRead(Message)	Określa, czy program formatujący może deserializować komunikat.
Clone()	Tworzy wystąpienie XmlMessageFormatter klasy, której właściwości odczytu/zapisu (zestawy typów docelowych) są takie same jak bieżące XmlMessageFormatter wystąpienie.
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
Read(Message)	Odczytuje zawartość danej wiadomości i tworzy obiekt, który zawiera zdeserializowany komunikat.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)
Write(Message, Object)	Serializuje obiekt w treści komunikatu.

Dotyczy