XmlMessageFormatter Konstruktoren

Referenz

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

XmlMessageFormatter()	Initialisiert eine neue Instanz der XmlMessageFormatter-Klasse ohne Angabe einer Gruppe von Zieltypen.
XmlMessageFormatter(String[])	Initialisiert eine neue Instanz der XmlMessageFormatter-Klasse und legt die übergebenen Zieltypen als ein Array von (voll gekennzeichneten) Zeichenfolgenwerten fest.
XmlMessageFormatter(Type[])	Initialisiert eine neue Instanz der XmlMessageFormatter-Klasse und legt die übergebenen Zieltypen als ein Array von Objekttypen fest.

XmlMessageFormatter()

Initialisiert eine neue Instanz der XmlMessageFormatter-Klasse ohne Angabe einer Gruppe von Zieltypen.

public:
 XmlMessageFormatter();

public XmlMessageFormatter ();

Public Sub New ()

Hinweise

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

Um eine Nachricht aus einer Warteschlange mit einer instance von zu lesen, die XmlMessageFormatter mit diesem Konstruktor erstellt wurde, müssen Sie die TargetTypeNames Eigenschaften oder TargetTypes festlegen, damit der Formatierer weiß, welche Typen deserialisiert werden sollen.

Wenn Sie eine neue MessageQueueerstellen, wird eine Standard-instance XmlMessageFormatter erstellt, ohne dass die Zieltypen festgelegt sind. Wie bei einem Formatierer, der mit diesem Konstruktor erstellt wurde, müssen Sie Zieltypen für diesen Formatierer festlegen, instance wenn Sie aus der Warteschlange lesen möchten.

Gilt für:

XmlMessageFormatter(String[])

Initialisiert eine neue Instanz der XmlMessageFormatter-Klasse und legt die übergebenen Zieltypen als ein Array von (voll gekennzeichneten) Zeichenfolgenwerten fest.

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 die Gruppe der möglichen Typen angibt, die vom Formatierungsprogramm aus der jeweiligen Meldung deserialisiert werden können. Diese Werte müssen voll gekennzeichnet 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. Wenn Sie diese Eigenschaft festlegen, können MessageQueue Sie mithilfe dieses XmlMessageFormatter instance Nachrichten lesen, die Objekte bestimmter Typen enthalten.

Sowohl die TargetTypeNames Eigenschaften als TargetTypes auch geben dem Formatierer an, welche Schemas beim Deserialisieren einer Nachricht übereinstimmen sollen. Dadurch kann der Formatierer den Nachrichtentext interpretieren.

Die im Nachrichtentext serialisierte instance muss einem der Schemas entsprechen, die im Typarray dargestellt werden. Wenn Sie die Nachricht mit der Receive -Methode lesen, erstellt die -Methode ein Objekt des Typs, der dem identifizierten Schema entspricht, und liest den Nachrichtentext darin ein.

Beim Lesen aus der Warteschlange muss nur eine der beiden Eigenschaften festgelegt werden, aber Sie können beide festlegen. Der Satz von Typen ist die kombinierte Menge aus den beiden Eigenschaften. Die Entscheidung, welche 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 beide Eigenschaften entspricht, wird zur Lesezeit eine Ausnahme ausgelöst.

Gilt für:

XmlMessageFormatter(Type[])

Initialisiert eine neue Instanz der XmlMessageFormatter-Klasse und legt die übergebenen Zieltypen als ein Array von Objekttypen fest.

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 die Gruppe der möglichen Typen angibt, die vom Formatierungsprogramm aus der jeweiligen Meldung deserialisiert werden können.

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 dieses XmlMessageFormatter instance Nachrichten gelesen werden, die Objekte der angegebenen Typen enthalten.

Wenn Anstelle von TargetTypeNamesangegeben TargetTypes wird, wird die Typexistenz zur Kompilierzeit statt zur Lesezeit überprüft, wodurch die Fehlergeminderbarkeit verringert wird. TargetTypeNames erfordert, dass jeder Eintrag voll qualifiziert ist, wobei der Assemblyname angegeben wird. Darüber hinaus muss bei der Arbeit mit mehreren gleichzeitigen Versionen auch die Versionsnummer an den Namen des Zieltyps angefügt werden.

TargetTypesWenn Sie verwenden, können Sie jedes Objekt (z. B. ) der Liste hinzufügen, MyClasswie im folgenden C#-Code veranschaulicht.

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

Gilt für:

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

Zusätzliche Ressourcen