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 to plik sformatowany w formacie XML opisujący "kształt" klasy. Ten schemat można następnie użyć po stronie klienta, aby wygenerować klasę zamówień specyficzną 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 jest zgodny z klasą Order.cs poniżej. 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ń odbieranych i deserializacji aplikacji na serwerze.

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 wchodzi w interakcję z aplikacją na serwerze, musi wysyłać komunikaty do serwera, serializując informacje w lokalnie zdefiniowanej klasie kolejności do treści komunikatu. Lokalnie zdefiniowana klasa kolejności musi mieć taki sam schemat jak zdefiniowana przez serwer klasa kolejności, 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 rozpowszechnianie schematu, który klient musi używać do serializacji komunikatów przechodzących do serwera.

Gdy menedżer aplikacji klienckiej odbiera schemat klasy order, narzędzie XSD.exe jest ponownie używane do generowania klasy zamówień specyficznych dla klienta ze schematu. Jest to ta klasa używana w poniższym przykładzie kodu klienta, a nie w klasie kolejności serwera (narzędzie XSD.exe powoduje, że klasa wygenerowana schematem ma taką samą nazwę jak oryginalna klasa). Ta nowa klasa zamówienia 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 wygenerowanymi 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ę. Jeśli schemat nie zostanie zmieniony, nie trzeba ponownie dystrybuować schematu. Po rozpowszechnieniu schematu i wygenerowaniu klasy zamówienia po stronie klienta można również zmodyfikować tę klasę klienta niezależnie od klasy zamówień serwera, o ile sam schemat nie jest modyfikowany. Dwie klasy stały się luźno powiązane.

Uwagi

Jest XmlMessageFormatter to domyślny formater, którego wystąpienie używa do serializacji komunikatów zapisanych MessageQueue w kolejce. Podczas tworzenia wystąpienia klasy jest tworzone wystąpienie MessageQueue XmlMessageFormatter obiektu 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 elementu MessageQueue.

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

Podczas określania TargetTypes , a nie TargetTypeNames, istnienie typu jest sprawdzane w czasie kompilacji, a nie w czasie odczytu, zmniejszając możliwość 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 numer wersji należy również dołączyć do nazwy typu docelowego.

Właściwości TargetTypeNames i TargetTypes informują formater, 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 odpowiadającego zidentyfikowaniu schematu 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ść do użycia jest specyficzna dla twojej aplikacji. Jeśli treść komunikatu zawiera typ, którego schemat nie pasuje do żadnego z typów w tablicy dla żadnej z właściwości, zostanie zgłoszony wyjątek podczas odczytywania komunikatu.

Jest XmlMessageFormatter to kluczowy składnik luźno powiązanej obsługi komunikatów opartych na języku 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óry 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 nowe wystąpienie klasy bez ustawionych XmlMessageFormatter 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 będą deserializowane przez formatator z dostarczonego komunikatu.
TargetTypes	Określa zestaw możliwych typów, które będą deserializowane przez formatator z dostarczonego komunikatu.

Metody

CanRead(Message)	Określa, czy formater 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 w bieżącym XmlMessageFormatter wystąpieniu.
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 bieżące wystąpienie. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
Read(Message)	Odczytuje zawartość danego komunikatu i tworzy obiekt zawierający deserializowany komunikat.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)
Write(Message, Object)	Serializuje obiekt w treści wiadomości.

Dotyczy

Udostępnij za pośrednictwem