XmlMessageFormatter XmlMessageFormatter XmlMessageFormatter XmlMessageFormatter Class

Definicja

Serializować i deserializacji obiektów do lub z treści wiadomości przy użyciu formatu XML na podstawie definicji schematu XSD.Serializes and deserializes objects to or from the body of a message, using the XML format based on the XSD schema 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
Dziedziczenie
XmlMessageFormatterXmlMessageFormatterXmlMessageFormatterXmlMessageFormatter
Implementuje

Przykłady

Poniższy przykład kodu zawiera trzy fragmenty kodu: składnik serwera, klasy zamówienia i kod klienta.The following code example includes three pieces of code: a server component, an order class, and client code. Klasa Order może być używana przez narzędzie XSD. exe do generowania schematu rozpoznawanego przez serwer w wiadomościach przychodzących.The order class can be used by the XSD.exe utility to generate schema that the server recognizes within incoming messages. Schemat jest plikiem w formacie XML, który opisuje "kształt" klasy.The schema is an XML formatted file that describes the "shape" of the class. Tego schematu można następnie użyć po stronie klienta do wygenerowania klasy kolejności specyficznej dla klienta, która współużytkuje ten sam schemat, co Klasa serwera.This schema can then be used on the client side to generate a client-specific order class that shares the same schema as the server class.

Poniższy przykład kodu reprezentuje składnik serwera, który odbiera zamówienia za pomocą kolejki komunikatów.The following code example represents a server component that receives orders through a message queue. Treść wiadomości powinna być obiektem Order, którego schemat pasuje do klasy Order.cs poniżej.The body of the message should be an order object whose schema matches the Order.cs class below. Proces serwera lub aplikacja deserializacji zamówienie.The server process or application deserializes the order.

#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 dla obiektów Order, które aplikacja na serwerze odbiera i deserializacji.The following code example represents the order class that provides a schema for the order objects that the application on the server receives and deserializes.

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

Wszystkie aplikacje klienckie, które współdziałają z aplikacją na serwerze programu, muszą wysyłać komunikaty do serwera przez Serializowanie informacji we zdefiniowanej lokalnie klasie Order w treści wiadomości.Any client application that interacts with the application on the server must send messages to the server by serializing information in a locally defined order class into the message body. Klasa kolejności zdefiniowana lokalnie musi mieć ten sam schemat jak Klasa kolejności zdefiniowana przez serwer, w której aplikacja na serwerze podejmie próbę deserializacji treści komunikatu.The locally defined order class must have the same schema as the server-defined order class into which the application on the server will attempt to deserialize the message body. Narzędzie XSD. exe umożliwia menedżerowi aplikacji na serwerze tworzenie i dystrybuowanie schematu, którego klient musi użyć do serializacji komunikatów wysyłanych do serwera.The XSD.exe utility lets the manager of the application on the server create and distribute the schema the client must use to serialize messages going to the server.

Gdy Menedżer aplikacji klienckiej odbierze schemat klasy Order, narzędzie XSD. exe jest używane ponownie w celu wygenerowania klasy kolejności specyficznej dla klienta ze schematu.When the manager of the client application receives the schema for the order class, the XSD.exe utility is used again to generate a client-specific order class from the schema. Jest to Klasa, która jest używana w poniższym przykładzie kodu klienta, a nie Klasa kolejności serwera (Narzędzie XSD. exe powoduje, że Klasa wygenerowana przez schemat ma taką samą nazwę jak oryginalna Klasa).It is this class that is used in the client code example below, not the server's order class (the XSD.exe utility causes the schema-generated class to have the same name as the original class). Ta nowa klasa Order służy do serializacji kolejności w treści wiadomości.This new order class is used to serialize the order into the message body.

Poniższy przykład kodu jest przetwarzaniem po stronie klienta używanym do serializacji zamówienia i wysyłania informacji skojarzonych z kolejnością do kolejki.The following code example is the client-side processing, used to serialize an order and send the information associated with the order to a queue. Kod kojarzy element, ilość i informacje o adresie z elementami schematu, które zostały wygenerowane dla klasy Order.cs przez narzędzie XSD. exe.The code associates Item, Quantity, and Address information with elements of the schema that were generated for the Order.cs class by the XSD.exe utility. Zamówienie jest wysyłane do kolejki Orders na komputerze lokalnym.An order is sent to the Orders queue on the local computer.

#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ę.After the schema is generated from the order class on the server, you can modify the class. Dopóki schemat nie ulegnie zmianie, nie trzeba ponownie rozpowszechniać schematu.Unless the schema changes, you do not need to redistribute the schema. Po przeprowadzeniu dystrybucji schematu i wygenerowaniu klasy kolejności po stronie klienta Ta klasa klienta może być również modyfikowana niezależnie od klasy kolejności serwera, o ile sam schemat nie jest modyfikowany.After you have distributed the schema and generated a client-side order class, that client class can also be modified independently of the server's order class, as long as the schema itself is not modified. Dwie klasy stają się luźno sprzężone.The two classes have become loosely coupled.

Uwagi

Jest to domyślny program formatujący, którego MessageQueue wystąpienie używa do serializacji wiadomości zapisanych do kolejki. XmlMessageFormatterThe XmlMessageFormatter is the default formatter that an instance of MessageQueue uses to serialize messages written to the queue. Po utworzeniu wystąpienia programu MessageQueue XmlMessageFormatter wystąpienie jest tworzone dla MessageQueueCiebie i skojarzone z.When you create an instance of MessageQueue, an instance of XmlMessageFormatter is created for you and associated with the MessageQueue. Możesz określić inny program formatujący, tworząc go w kodzie i przypisując go do Formatter właściwości. MessageQueueYou can specify a different formatter by creating it in your code and assigning it to the Formatter property of your MessageQueue.

Domyślnego XmlMessageFormatter wystąpienia kolejki można użyć do zapisu w kolejce, ale nie można go użyć do odczytu z kolejki do momentu ustawienia TargetTypes właściwości lub TargetTypeNames w programie formatującego.A queue's default XmlMessageFormatter instance can be used to write to the queue, but it cannot be used to read from the queue until you set either the TargetTypes or TargetTypeNames property on the formatter. Można ustawić jedną lub obie te wartości w domyślnym wystąpieniu programu formatującego lub utworzyć nowe wystąpienie programu formatującego i ustawić wartości automatycznie przez przekazanie ich jako argumentów do odpowiedniego XmlMessageFormatter konstruktora.You can either set one or both of these values on the default formatter instance, or you can create a new instance of the formatter and set the values automatically by passing them as arguments into the appropriate XmlMessageFormatter constructor.

Kiedy określasz TargetTypes TargetTypeNames, zamiast, typ istnienia jest sprawdzany w czasie kompilacji zamiast czasu odczytu, zmniejszenie możliwości błędu.When specifying TargetTypes rather than TargetTypeNames, type existence is checked at compile time rather than read time, reducing possibility for error. TargetTypeNameswymaga, aby każdy wpis był w pełni kwalifikowany, określając jego nazwę zestawu.TargetTypeNames requires every entry to be fully qualified, specifying its assembly name. Ponadto w przypadku pracy z wieloma współbieżnymi wersjami numer wersji również musi być dołączony do nazwy typu docelowego.Further, when working with multiple concurrent versions, the version number must also be appended to the target type name as well.

Właściwości TargetTypeNames iTargetTypes informują program formatujący, jakie schematy próbują dopasować podczas deserializacji komunikatu.The TargetTypeNames and TargetTypes properties tell the formatter what schemas to attempt to match when deserializing a message. Dzięki temu program formatujący interpretuje treść wiadomości.This allows the formatter to interpret the message body.

Serializacja wystąpienia w treści komunikatu musi być zgodna z jednym ze schematów przedstawionych w tablicy typów.The instance serialized in the message body must comply with one of the schemas represented in the type array. Gdy odczytujesz komunikat przy użyciu Receive metody, metoda tworzy obiekt typu, który odpowiada określonemu schematowi i odczytuje do niego treść komunikatu.When you read the message using the Receive method, the method creates an object of the type that corresponds to the schema identified and reads the message body into it.

Podczas odczytywania z kolejki należy ustawić tylko jedną z tych właściwości, ale można ustawić oba typy.Only one of the two properties needs to be set when reading from the queue, but you can set both. Zestaw typów jest zestawem połączonym z dwóch właściwości.The set of types is the combined set from the two properties. Decyzja o tym, która właściwość powinna zostać użyta, jest specyficzna dla Twojej aplikacji.The decision of which property to use is specific to your application. Jeśli treść wiadomości zawiera typ, którego schemat nie pasuje do żadnego z typów w tablicy dla jednej z tych właściwości, zostanie zgłoszony wyjątek podczas odczytywania komunikatu.If the message body contains a type whose schema does not match any of the types in the array for either property, an exception will be thrown when the message is read.

XmlMessageFormatter Jest kluczowym składnikiem luźno sprzężonych komunikatów opartych na języku XML.The XmlMessageFormatter is a crucial component of loosely coupled XML-based messaging. Narzędzie XSD. exe używa formatu XML do generowania schematu XML, na przykład podczas korzystania z narzędzia do serializacji klasy używanej przez aplikację.The XSD.exe utility uses the XML format is used to generate XML schema, such as when you use the utility to serialize a class used by your application. Klasa musi mieć konstruktora bez parametrów.The class must have a parameterless constructor.

Ten format jest używany ponownie w procesie wycofywania, gdy narzędzie generuje klasę na podstawie dystrybuowanego schematu, aby opisać dane klasy.The format is used again in the reverse process when the utility generates a class based on the schema you distribute to describe your class data. Użycie narzędzia i schematu XML, który generuje, umożliwia uniknięcie redystrybucji plików DLL przy każdym ponownym skompilowaniu klasy po zmianie implementacji klasy.The use of the utility and the XML schema it generates enables you to avoid redistributing.dll files every time you recompile a class after the implementation of your class has changed. Dopóki schemat nie ulegnie zmianie na kliencie lub serwerze, inne zmiany po obu stronach nie wpływają na inne.As long as the schema does not change on the client or the server, other changes on either side do not affect the other.

Konstruktory

XmlMessageFormatter() XmlMessageFormatter() XmlMessageFormatter() XmlMessageFormatter()

Inicjuje nowe wystąpienie XmlMessageFormatter klasy, bez ustawionego typu docelowego.Initializes a new instance of the XmlMessageFormatter class, without target types set.

XmlMessageFormatter(String[]) XmlMessageFormatter(String[]) XmlMessageFormatter(String[]) XmlMessageFormatter(String[])

Inicjuje nowe wystąpienie XmlMessageFormatter klasy, ustawiając typy docelowe przenoszone jako tablica wartości ciągu (w pełni kwalifikowanych).Initializes a new instance of the XmlMessageFormatter class, setting target types passed in as an array of (fully qualified) string values.

XmlMessageFormatter(Type[]) XmlMessageFormatter(Type[]) XmlMessageFormatter(Type[]) XmlMessageFormatter(Type[])

Inicjuje nowe wystąpienie XmlMessageFormatter klasy, ustawiając typy docelowe przenoszone jako tablica typów obiektów.Initializes a new instance of the XmlMessageFormatter class, setting target types passed in as an array of object types.

Właściwości

TargetTypeNames TargetTypeNames TargetTypeNames TargetTypeNames

Określa zestaw możliwych typów, które zostaną rozszeregowane przez program formatujący z podanej wiadomości.Specifies the set of possible types that will be deserialized by the formatter from the message provided.

TargetTypes TargetTypes TargetTypes TargetTypes

Określa zestaw możliwych typów, które zostaną rozszeregowane przez program formatujący z podanej wiadomości.Specifies the set of possible types that will be deserialized by the formatter from the message provided.

Metody

CanRead(Message) CanRead(Message) CanRead(Message) CanRead(Message)

Określa, czy program formatujący może deserializować komunikat.Determines whether the formatter can deserialize the message.

Clone() Clone() Clone() 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.Creates an instance of the XmlMessageFormatter class whose read/write properties (the sets of target types) are the same as the current XmlMessageFormatter instance.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Type Pobiera bieżące wystąpienie.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Tworzy skróconą kopię bieżącego Objectelementu.Creates a shallow copy of the current Object.

(Inherited from Object)
Read(Message) Read(Message) Read(Message) Read(Message)

Odczytuje zawartość z danego komunikatu i tworzy obiekt, który zawiera deserializowany komunikat.Reads the contents from the given message and creates an object that contains the deserialized message.

ToString() ToString() ToString() ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Inherited from Object)
Write(Message, Object) Write(Message, Object) Write(Message, Object) Write(Message, Object)

Serializacja obiektu w treści wiadomości.Serializes an object into the body of the message.

Dotyczy

Zobacz też