XmlMessageFormatter Construtores

Definição

Inicializa uma nova instância da classe XmlMessageFormatter.Initializes a new instance of the XmlMessageFormatter class.

Sobrecargas

XmlMessageFormatter()

Inicializa uma nova instância da classe XmlMessageFormatter, sem tipos de destino definidos.Initializes a new instance of the XmlMessageFormatter class, without target types set.

XmlMessageFormatter(String[])

Inicializa uma nova instância da classe XmlMessageFormatter, definindo os tipos de destino passados como uma matriz de valores de cadeia de caracteres (totalmente qualificados).Initializes a new instance of the XmlMessageFormatter class, setting target types passed in as an array of (fully qualified) string values.

XmlMessageFormatter(Type[])

Inicializa uma nova instância da classe XmlMessageFormatter, definindo tipos de destino transmitidos como uma matriz de tipos de objeto.Initializes a new instance of the XmlMessageFormatter class, setting target types passed in as an array of object types.

XmlMessageFormatter()

Inicializa uma nova instância da classe XmlMessageFormatter, sem tipos de destino definidos.Initializes a new instance of the XmlMessageFormatter class, without target types set.

public:
 XmlMessageFormatter();
public XmlMessageFormatter ();
Public Sub New ()

Comentários

Essa sobrecarga do construtor é usada com mais frequência ao gravar na fila, pois os tipos de destino não são necessários durante a gravação.This overload of the constructor is used most frequently when writing to the queue, as target types are not required when writing.

Para ler uma mensagem de uma fila usando uma instância do XmlMessageFormatter criada usando esse construtor, você deve definir as TargetTypeNames TargetTypes Propriedades ou para que o formatador saiba quais tipos tentar desserializar.To read a message from a queue using an instance of XmlMessageFormatter created using this constructor, you must set the TargetTypeNames or TargetTypes properties so the formatter knows what types to attempt to deserialize.

Quando você cria um novo MessageQueue , uma XmlMessageFormatter instância padrão é criada, sem os tipos de destino definidos.When you create a new MessageQueue, a default XmlMessageFormatter instance is created, without the target types set. Assim como com um formatador criado com esse construtor, você deve definir tipos de destino para essa instância do formatador se desejar ler a partir da fila.As with a formatter created using this constructor, you must set target types for that formatter instance if you want to read from the queue.

Aplica-se a

XmlMessageFormatter(String[])

Inicializa uma nova instância da classe XmlMessageFormatter, definindo os tipos de destino passados como uma matriz de valores de cadeia de caracteres (totalmente qualificados).Initializes a new instance of the XmlMessageFormatter class, setting target types passed in as an array of (fully qualified) string values.

public:
 XmlMessageFormatter(cli::array <System::String ^> ^ targetTypeNames);
public XmlMessageFormatter (string[] targetTypeNames);
new System.Messaging.XmlMessageFormatter : string[] -> System.Messaging.XmlMessageFormatter
Public Sub New (targetTypeNames As String())

Parâmetros

targetTypeNames
String[]

Uma matriz do tipo String que especifica o conjunto dos possíveis tipos que serão desserializados pelo formatador da mensagem fornecida.An array of type String that specifies the set of possible types that will be deserialized by the formatter from the message provided. Esses valores devem ser totalmente qualificados, por exemplo, “MyNamespace.MyOrders, MyOrdersAssemblyName”.These values must be fully qualified, for example, "MyNamespace.MyOrders, MyOrdersAssemblyName".

Exceções

O parâmetro targetTypeNames é null.The targetTypeNames parameter is null.

Exemplos

#using <system.dll>
#using <system.messaging.dll>
#using <system.drawing.dll>

using namespace System;
using namespace System::Messaging;
using namespace System::Drawing;
using namespace System::IO;
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};

ref class MyNewQueue
{
public:
   static void CreateQueue( String^ queuePath )
   {
      try
      {
         if (  !MessageQueue::Exists( queuePath ) )
         {
            MessageQueue::Create( queuePath );
         }
         else
         {
            Console::WriteLine(  "{0} already exists.", queuePath );
         }
      }
      catch ( MessageQueueException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   void SendMessage()
   {
      try
      {
         // Create a new order and set values.
         Order^ sentOrder = gcnew Order;
         sentOrder->orderId = 3;
         sentOrder->orderTime = DateTime::Now;

         // Connect to a queue on the local computer.
         MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

         // Create the new order.
         Message^ myMessage = gcnew Message( sentOrder );

         // Send the order to the queue.
         myQueue->Send( myMessage );
      }
      catch ( ArgumentException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      return;
   }

   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Order^ myOrder = dynamic_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Create a queue on the local computer.
   MyNewQueue::CreateQueue( ".\\myQueue" );

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}
using System;
using System.Messaging;
using System.Drawing;
using System.IO;

namespace MyProject
{

    // The following example
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Create a queue on the local computer.
            CreateQueue(".\\myQueue");
            
            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Creates a new queue.
        //**************************************************

        public static void CreateQueue(string queuePath)
        {
            try	
            {
                if(!MessageQueue.Exists(queuePath))
                {
                    MessageQueue.Create(queuePath);
                }
                else
                {
                    Console.WriteLine(queuePath + " already exists.");
                }
            }
            catch (MessageQueueException e)
            {
                Console.WriteLine(e.Message);
            }
        }

        //**************************************************
        // Sends an Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            try
            {

                // Create a new order and set values.
                Order sentOrder = new Order();
                sentOrder.orderId = 3;
                sentOrder.orderTime = DateTime.Now;

                // Connect to a queue on the local computer.
                MessageQueue myQueue = new MessageQueue(".\\myQueue");

                // Create the new order.
                Message myMessage = new Message(sentOrder);

                // Send the order to the queue.
                myQueue.Send(myMessage);
            }
            catch(ArgumentException e)
            {
                Console.WriteLine(e.Message);
            }

            return;
        }

        //**************************************************
        // Receives a message containing an order.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                Message myMessage =	myQueue.Receive();
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

                // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}
Imports System.Messaging
Imports System.Drawing
Imports System.IO



   
' The following example 
' sends to a queue and receives from a queue.
Public Class Order
      Public orderId As Integer
      Public orderTime As DateTime
End Class

   
  
' Provides a container class for the example.

Public Class MyNewQueue
      
      

   ' Provides an entry point into the application.
   '		 
   ' This example sends and receives a message from
   ' a queue.

   Public Shared Sub Main()
      ' Create a new instance of the class.
      Dim myNewQueue As New MyNewQueue()
        
      ' Create a queue on the local computer.
      CreateQueue(".\myQueue")
         
      ' Send a message to a queue.
      myNewQueue.SendMessage()
       
      ' Receive a message from a queue.
      myNewQueue.ReceiveMessage()
         
      Return
   End Sub
      
      

      ' Creates a new queue.
   Public Shared Sub CreateQueue(queuePath As String)
      Try
         If Not MessageQueue.Exists(queuePath) Then
            MessageQueue.Create(queuePath)
         Else
            Console.WriteLine((queuePath + " already exists."))
         End If
      Catch e As MessageQueueException
         Console.WriteLine(e.Message)
      End Try
   End Sub
       
      

      ' Sends an Order to a queue.

   Public Sub SendMessage()
      Try
            
            ' Create a new order and set values.
            Dim sentOrder As New Order()
            sentOrder.orderId = 3
            sentOrder.orderTime = DateTime.Now
            
            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            
            
            ' Create the new order.
            Dim myMessage As New Message(sentOrder)
            
            ' Send the order to the queue.
            myQueue.Send(myMessage)
      Catch e As ArgumentException
            Console.WriteLine(e.Message)
      End Try 
         
      Return
   End Sub
      
      
      
 
      ' Receives a message containing an order.
 
   Public Sub ReceiveMessage()
         ' Connect to the a queue on the local computer.
         Dim myQueue As New MessageQueue(".\myQueue")
         
         ' Set the formatter to indicate body contains an Order.
         myQueue.Formatter = New XmlMessageFormatter(New Type() {GetType(Order)})
         
         Try
            ' Receive and format the message. 
            Dim myMessage As Message = myQueue.Receive()
            Dim myOrder As Order = CType(myMessage.Body, Order)
            
            ' Display message information.
            Console.WriteLine(("Order ID: " + myOrder.orderId.ToString()))
            Console.WriteLine(("Sent: " + myOrder.orderTime.ToString()))
         
  
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         End Try
         
         ' Catch other exceptions as necessary.
         Return
   End Sub
End Class

Comentários

Os construtores com parâmetros de tipo de destino são usados com mais frequência ao ler da fila.The constructors with target type parameters are most frequently used when reading from the queue. Ao escrever, não é necessário especificar os tipos de destino.When writing, it is not necessary to specify target types.

Essa sobrecarga do XmlMessageFormatter construtor define a TargetTypeNames propriedade para os valores de matriz passados por meio do targetTypeNames parâmetro.This overload of the XmlMessageFormatter constructor sets the TargetTypeNames property to the array values passed in through the targetTypeNames parameter. Definir essa propriedade permite que um MessageQueue usando essa XmlMessageFormatter instância Leia mensagens contendo objetos de tipos fornecidos.Setting this property enables a MessageQueue using this XmlMessageFormatter instance to read messages containing objects of given types.

As TargetTypeNames Propriedades e TargetTypes dizem ao formatador quais esquemas tentar corresponder ao desserializar uma mensagem.Both the TargetTypeNames and TargetTypes properties tell the formatter what schemas to attempt to match when deserializing a message. Isso permite que o formatador interprete o corpo da mensagem.This allows the formatter to interpret the message body.

A instância serializada no corpo da mensagem deve estar em conformidade com um dos esquemas representados na matriz de tipos.The instance serialized in the message body must comply with one of the schemas represented in the type array. Quando você lê a mensagem usando o Receive método, o método cria um objeto do tipo que corresponde ao esquema identificado e lê o corpo da mensagem nele.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.

Somente uma das duas propriedades precisa ser definida durante a leitura da fila, mas você pode definir ambas.Only one of the two properties needs to be set when reading from the queue, but you can set both. O conjunto de tipos é o conjunto combinado das duas propriedades.The set of types is the combined set from the two properties. A decisão de qual usar é específica para seu aplicativo.The decision of which one to use is specific to your application. Se o corpo da mensagem contiver um tipo cujo esquema não corresponde a nenhum dos tipos na matriz para qualquer propriedade, uma exceção será lançada em tempo de leitura.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 at read time.

Aplica-se a

XmlMessageFormatter(Type[])

Inicializa uma nova instância da classe XmlMessageFormatter, definindo tipos de destino transmitidos como uma matriz de tipos de objeto.Initializes a new instance of the XmlMessageFormatter class, setting target types passed in as an array of object types.

public:
 XmlMessageFormatter(cli::array <Type ^> ^ targetTypes);
public XmlMessageFormatter (Type[] targetTypes);
new System.Messaging.XmlMessageFormatter : Type[] -> System.Messaging.XmlMessageFormatter
Public Sub New (targetTypes As Type())

Parâmetros

targetTypes
Type[]

Uma matriz do tipo Type que especifica o conjunto dos possíveis tipos que serão desserializados pelo formatador da mensagem fornecida.An array of type Type that specifies the set of possible types that will be deserialized by the formatter from the message provided.

Exceções

O parâmetro targetTypes é null.The targetTypes parameter is null.

Comentários

Os construtores com parâmetros de tipo de destino são usados com mais frequência ao ler da fila.The constructors with target type parameters are most frequently used when reading from the queue. Ao escrever, não é necessário especificar os tipos de destino.When writing, it is not necessary to specify target types.

Essa sobrecarga do XmlMessageFormatter construtor define a TargetTypes propriedade para os valores de matriz passados por meio do targetTypes parâmetro.This overload of the XmlMessageFormatter constructor sets the TargetTypes property to the array values passed in through the targetTypes parameter. Definir essa propriedade permite que um MessageQueue usando essa XmlMessageFormatter instância Leia mensagens contendo objetos dos tipos especificados.Setting this property enables a MessageQueue using this XmlMessageFormatter instance to read messages containing objects of the given types.

As TargetTypeNames Propriedades e TargetTypes dizem ao formatador quais esquemas tentar corresponder ao desserializar uma mensagem.Both the TargetTypeNames and TargetTypes properties tell the formatter what schemas to attempt to match when deserializing a message. Isso permite que o formatador interprete o corpo da mensagem.This allows the formatter to interpret the message body.

A instância serializada no corpo da mensagem deve estar em conformidade com um dos esquemas representados na matriz de tipos.The instance serialized in the message body must comply with one of the schemas represented in the type array. Quando você lê a mensagem usando o Receive método, o método cria um objeto do tipo que corresponde ao esquema identificado e lê o corpo da mensagem nele.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.

Somente uma das duas propriedades precisa ser definida durante a leitura da fila, mas você pode definir ambas.Only one of the two properties needs to be set when reading from the queue, but you can set both. O conjunto de tipos é o conjunto combinado das duas propriedades.The set of types is the combined set from the two properties. A decisão de qual usar é específica para seu aplicativo.The decision of which one to use is specific to your application. Se o corpo da mensagem contiver um tipo cujo esquema não corresponde a nenhum dos tipos na matriz para qualquer propriedade, uma exceção será lançada em tempo de leitura.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 at read time.

Ao especificar TargetTypes em vez de TargetTypeNames , a existência de tipo é verificada em tempo de compilação em vez de tempo de leitura, reduzindo a possibilidade de erro.When specifying TargetTypes rather than TargetTypeNames, type existence is checked at compile time rather than read time, reducing possibility for error. TargetTypeNames requer que cada entrada seja totalmente qualificada, especificando seu nome de assembly.TargetTypeNames requires every entry to be fully qualified, specifying its assembly name. Além disso, ao trabalhar com várias versões simultâneas, o número de versão também deve ser anexado ao nome do tipo de destino.Further, when working with multiple concurrent versions, the version number must also be appended to the target type name as well.

Ao usar TargetTypes o, você pode adicionar cada objeto (por exemplo, MyClass ) à lista de uma maneira demonstrada pelo código C# a seguir.When using TargetTypes, you can add each object (for example, MyClass) to the list in a way demonstrated by the following C# code.

TargetTypes = new Type[]{typeof(MyClass)}  

Aplica-se a