XmlMessageFormatter Konstruktor

Definisi

Ruang nama:

System.Messaging

Rakitan:

System.Messaging.dll

Menginisialisasi instans baru kelas XmlMessageFormatter.

Overload

XmlMessageFormatter()	Menginisialisasi instans XmlMessageFormatter baru kelas, tanpa jenis target yang ditetapkan.
XmlMessageFormatter(String[])	Menginisialisasi instans XmlMessageFormatter baru kelas, mengatur jenis target yang diteruskan sebagai array nilai string (sepenuhnya memenuhi syarat).
XmlMessageFormatter(Type[])	Menginisialisasi instans XmlMessageFormatter baru kelas, mengatur jenis target yang diteruskan sebagai array jenis objek.

XmlMessageFormatter()

Menginisialisasi instans XmlMessageFormatter baru kelas, tanpa jenis target yang ditetapkan.

public:
 XmlMessageFormatter();

public XmlMessageFormatter ();

Public Sub New ()

Keterangan

Kelebihan beban konstruktor ini paling sering digunakan saat menulis ke antrean, karena jenis target tidak diperlukan saat menulis.

Untuk membaca pesan dari antrean XmlMessageFormatter menggunakan instans yang dibuat menggunakan konstruktor ini, Anda harus mengatur TargetTypeNames properti atau TargetTypes sehingga pemformat mengetahui jenis apa yang ingin dideserialisasi.

Saat Anda membuat baru MessageQueue, instans default XmlMessageFormatter dibuat, tanpa jenis target yang ditetapkan. Seperti halnya pemformat yang dibuat menggunakan konstruktor ini, Anda harus mengatur jenis target untuk instans formatter tersebut jika Anda ingin membaca dari antrean.

XmlMessageFormatter(String[])

Menginisialisasi instans XmlMessageFormatter baru kelas, mengatur jenis target yang diteruskan sebagai array nilai string (sepenuhnya memenuhi syarat).

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[]

Array jenis String yang menentukan kumpulan jenis yang mungkin akan dideserialisasi oleh pemformat dari pesan yang disediakan. Nilai-nilai ini harus sepenuhnya memenuhi syarat, misalnya, "MyNamespace.MyOrders, MyOrdersAssemblyName".

Pengecualian

ArgumentNullException

Parameternya targetTypeNames adalah null.

Contoh

#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

Keterangan

Konstruktor dengan parameter jenis target paling sering digunakan saat membaca dari antrean. Saat menulis, tidak perlu menentukan jenis target.

Kelebihan beban XmlMessageFormatter konstruktor ini mengatur TargetTypeNames properti ke nilai array yang diteruskan melalui targetTypeNames parameter . Mengatur properti ini memungkinkan penggunaan instans MessageQueue ini XmlMessageFormatter untuk membaca pesan yang berisi objek dari jenis tertentu.

TargetTypeNames Properti dan TargetTypes memberi tahu pemformat skema apa yang akan dicocokkan saat mendeserialisasi pesan. Ini memungkinkan pemformat untuk menginterpretasikan isi pesan.

Instans yang diserialisasikan dalam isi pesan harus mematuhi salah satu skema yang diwakili dalam array jenis. Saat Anda membaca pesan menggunakan Receive metode , metode membuat objek jenis yang sesuai dengan skema yang diidentifikasi dan membaca isi pesan ke dalamnya.

Hanya salah satu dari dua properti yang perlu diatur saat membaca dari antrean, tetapi Anda dapat mengatur keduanya. Kumpulan jenis adalah kumpulan gabungan dari dua properti. Keputusan mana yang akan digunakan khusus untuk aplikasi Anda. Jika isi pesan berisi jenis yang skemanya tidak cocok dengan salah satu jenis dalam array untuk salah satu properti, pengecualian akan dilemparkan pada waktu baca.

XmlMessageFormatter(Type[])

Menginisialisasi instans XmlMessageFormatter baru kelas, mengatur jenis target yang diteruskan sebagai array jenis objek.

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[]

Array jenis Type yang menentukan kumpulan jenis yang mungkin akan dideserialisasi oleh pemformat dari pesan yang disediakan.

Pengecualian

ArgumentNullException

Parameternya targetTypes adalah null.

Keterangan

Konstruktor dengan parameter jenis target paling sering digunakan saat membaca dari antrean. Saat menulis, tidak perlu menentukan jenis target.

Kelebihan beban XmlMessageFormatter konstruktor ini mengatur TargetTypes properti ke nilai array yang diteruskan melalui targetTypes parameter . Mengatur properti ini memungkinkan penggunaan instans MessageQueue ini XmlMessageFormatter untuk membaca pesan yang berisi objek dari jenis yang diberikan.

TargetTypeNames Properti dan TargetTypes memberi tahu pemformat skema apa yang akan dicocokkan saat mendeserialisasi pesan. Ini memungkinkan pemformat untuk menginterpretasikan isi pesan.

Instans yang diserialisasikan dalam isi pesan harus mematuhi salah satu skema yang diwakili dalam array jenis. Saat Anda membaca pesan menggunakan Receive metode , metode membuat objek jenis yang sesuai dengan skema yang diidentifikasi dan membaca isi pesan ke dalamnya.

Hanya salah satu dari dua properti yang perlu diatur saat membaca dari antrean, tetapi Anda dapat mengatur keduanya. Kumpulan jenis adalah kumpulan gabungan dari dua properti. Keputusan mana yang akan digunakan khusus untuk aplikasi Anda. Jika isi pesan berisi jenis yang skemanya tidak cocok dengan salah satu jenis dalam array untuk salah satu properti, pengecualian akan dilemparkan pada waktu baca.

Saat menentukan TargetTypes bukan TargetTypeNames, keberadaan jenis diperiksa pada waktu kompilasi daripada waktu baca, mengurangi kemungkinan kesalahan. TargetTypeNames mengharuskan setiap entri sepenuhnya memenuhi syarat, menentukan nama assembly-nya. Selanjutnya, saat bekerja dengan beberapa versi bersamaan, nomor versi juga harus ditambahkan ke nama jenis target juga.

Saat menggunakan TargetTypes, Anda dapat menambahkan setiap objek (misalnya, MyClass) ke daftar dengan cara yang ditunjukkan oleh kode C# berikut.

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