XmlMessageFormatter Konstruktoren

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.

Initialisiert eine neue Instanz der XmlMessageFormatter-Klasse.

Überlädt

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.

XmlMessageFormatter()

Initialisiert eine neue Instanz der XmlMessageFormatter Klasse, ohne dass Zieltypen festgelegt sind.

public:
 XmlMessageFormatter();

public XmlMessageFormatter();

Public Sub New ()

Hinweise

Diese Überladung des Konstruktors wird am häufigsten beim Schreiben in die Warteschlange verwendet, da Zieltypen beim Schreiben nicht erforderlich sind.

Zum Lesen einer Nachricht aus einer Warteschlange mithilfe einer Instanz, die XmlMessageFormatter mit diesem Konstruktor erstellt wurde, müssen Sie die TargetTypeNames Oder-Eigenschaften TargetTypes festlegen, damit der Formatierer weiß, welche Typen versucht werden sollen, deserialisiert zu werden.

Wenn Sie eine neue MessageQueueInstanz erstellen, wird eine Standardinstanz XmlMessageFormatter erstellt, ohne dass die Zieltypen festgelegt sind. Wie bei einem mit diesem Konstruktor erstellten Formatierer müssen Sie Zieltypen für diese Formatierinstanz festlegen, wenn Sie aus der Warteschlange lesen möchten.

Gilt für:

XmlMessageFormatter(String[])

Initialisiert eine neue Instanz der XmlMessageFormatter Klasse, wobei das Festlegen von Zieltypen, die als Array von (vollqualifizierten) Zeichenfolgenwerten übergeben werden.

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())

Parameter

targetTypeNames: String[]

Ein Array vom Typ String , das den Satz möglicher Typen angibt, die vom Formatierer der bereitgestellten Nachricht deserialisiert werden. Diese Werte müssen vollqualifizierte sein, z. B. "MyNamespace.MyOrders, MyOrdersAssemblyName".

Ausnahmen

ArgumentNullException

Der targetTypeNames Parameter ist null.

Beispiele

#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

Hinweise

Die Konstruktoren mit Zieltypparametern werden am häufigsten beim Lesen aus der Warteschlange verwendet. Beim Schreiben ist es nicht erforderlich, Zieltypen anzugeben.

Diese Überladung des XmlMessageFormatter Konstruktors legt die TargetTypeNames Eigenschaft auf die Arraywerte fest, die über den targetTypeNames Parameter übergeben werden. Durch Festlegen dieser Eigenschaft kann mithilfe MessageQueue dieser XmlMessageFormatter Instanz Nachrichten gelesen werden, die Objekte von bestimmten Typen enthalten.

Sowohl die Eigenschaften als TargetTypes auch die TargetTypeNames Eigenschaften teilen dem Formatierer mit, 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, von der eine für Ihre Anwendung verwendet werden soll, ist spezifisch für Ihre Anwendung. Wenn der Nachrichtentext einen Typ enthält, dessen Schema keinem der Typen im Array für eine der Eigenschaften entspricht, wird eine Ausnahme zum Lesezeitpunkt ausgelöst.

Gilt für:

XmlMessageFormatter(Type[])

Initialisiert eine neue Instanz der XmlMessageFormatter Klasse, wobei Zieltypen festgelegt werden, die als Array von Objekttypen übergeben werden.

public:
 XmlMessageFormatter(cli::array <Type ^> ^ targetTypes);

public XmlMessageFormatter(Type[] targetTypes);

new System.Messaging.XmlMessageFormatter : Type[] -> System.Messaging.XmlMessageFormatter

Public Sub New (targetTypes As Type())

Parameter

targetTypes: Type[]

Ein Array vom Typ Type , das den Satz möglicher Typen angibt, die vom Formatierer der bereitgestellten Nachricht deserialisiert werden.

Ausnahmen

ArgumentNullException

Der targetTypes Parameter ist null.

Hinweise

Die Konstruktoren mit Zieltypparametern werden am häufigsten beim Lesen aus der Warteschlange verwendet. Beim Schreiben ist es nicht erforderlich, Zieltypen anzugeben.

Diese Überladung des XmlMessageFormatter Konstruktors legt die TargetTypes Eigenschaft auf die Arraywerte fest, die über den targetTypes Parameter übergeben werden. Durch Festlegen dieser Eigenschaft kann mithilfe MessageQueue dieser XmlMessageFormatter Instanz Nachrichten gelesen werden, die Objekte der angegebenen Typen enthalten.

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.

Bei Verwendung TargetTypeskönnen Sie jedes Objekt (z. B. ) der Liste auf eine Weise hinzufügen, MyClassdie durch den folgenden C#-Code veranschaulicht wird.

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

Gilt für:

Feedback

War diese Seite hilfreich?

Freigeben über

XmlMessageFormatter Konstruktoren

Definition

Überlädt

XmlMessageFormatter()

Hinweise

Gilt für:

XmlMessageFormatter(String[])

Parameter

Ausnahmen

Beispiele

Hinweise

Gilt für:

XmlMessageFormatter(Type[])

Parameter

Ausnahmen

Hinweise

Gilt für:

Feedback