XmlMessageFormatter 建構函式

參考

定義

命名空間:: System.Messaging

組件:: System.Messaging.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

初始化 XmlMessageFormatter 類別的新執行個體。

多載

XmlMessageFormatter()	不使用目標型別 (Target Type) 集來初始化 XmlMessageFormatter 類別的新執行個體。
XmlMessageFormatter(String[])	初始化 XmlMessageFormatter 類別的新執行個體，將傳入的目標型別設定為 (完整的) 字串值陣列。
XmlMessageFormatter(Type[])	初始化 XmlMessageFormatter 類別的新執行個體，將傳入的目標型別設定為物件型別的陣列。

XmlMessageFormatter()

不使用目標型別 (Target Type) 集來初始化 XmlMessageFormatter 類別的新執行個體。

public:
 XmlMessageFormatter();

public XmlMessageFormatter ();

Public Sub New ()

備註

寫入佇列時最常使用這個建構函式的多載，因為寫入時不需要目標類型。

若要使用這個建構函式建立的 XmlMessageFormatter 實例從佇列讀取訊息，您必須設定 TargetTypeNames 或 TargetTypes 屬性，讓格式器知道要嘗試還原串行化的型別。

當您建立新的 MessageQueue時，會建立預設 XmlMessageFormatter 實例，而不會設定目標類型。如同使用此建構函式建立的格式器，如果您想要從佇列讀取，則必須設定該格式子實例的目標類型。

適用於

XmlMessageFormatter(String[])

初始化 XmlMessageFormatter 類別的新執行個體，將傳入的目標型別設定為 (完整的) 字串值陣列。

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

參數

targetTypeNames: String[]

String 型別的陣列，指定可能型別的設定，格式子會從所提供的訊息還原序列化這些型別。這些值必須是完整的，例如「MyNamespace.MyOrders, MyOrdersAssemblyName」。

例外狀況

ArgumentNullException

targetTypeNames 參數為 null。

範例

#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

備註

從佇列讀取時，最常使用具有目標類型參數的建構函式。撰寫時，不需要指定目標類型。

這個建 XmlMessageFormatter 構函式的多載會將 TargetTypeNames 屬性設定為透過參數傳入的 targetTypeNames 陣列值。設定這個屬性可讓 MessageQueue 使用此 XmlMessageFormatter 實例來讀取包含指定型別物件的訊息。

TargetTypeNames和 TargetTypes 屬性都會告訴格式器在還原串行化訊息時，要嘗試比對的架構。這可讓格式器解譯訊息本文。

訊息本文中串行化的實例必須符合類型數位中所表示的其中一個架構。當您使用 Receive 方法讀取訊息時，方法會建立型別的物件，該對象對應至所識別的架構，並將訊息本文讀入其中。

從佇列讀取時，只需要設定兩個屬性的其中一個，但您可以設定這兩個屬性。型別集合是來自兩個屬性的合併集。要使用哪一個應用程式專屬的決策。如果訊息本文包含的類型，其架構不符合任一屬性之陣列中的任何類型，則會在讀取時擲回例外狀況。

適用於

XmlMessageFormatter(Type[])

初始化 XmlMessageFormatter 類別的新執行個體，將傳入的目標型別設定為物件型別的陣列。

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

public XmlMessageFormatter (Type[] targetTypes);

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

Public Sub New (targetTypes As Type())

參數

targetTypes: Type[]

Type 型別的陣列，指定可能型別的設定，格式子會從所提供的訊息還原序列化這些型別。

例外狀況

ArgumentNullException

targetTypes 參數為 null。

備註

從佇列讀取時，最常使用具有目標類型參數的建構函式。撰寫時，不需要指定目標類型。

這個建 XmlMessageFormatter 構函式的多載會將 TargetTypes 屬性設定為透過參數傳入的 targetTypes 陣列值。設定這個屬性可讓 MessageQueue 使用此 XmlMessageFormatter 實例讀取包含指定型別物件的訊息。

TargetTypeNames和 TargetTypes 屬性都會告訴格式器在還原串行化訊息時，要嘗試比對的架構。這可讓格式器解譯訊息本文。

指定 TargetTypes 而非 TargetTypeNames時，會在編譯時期檢查類型是否存在，而不是讀取時間，以減少錯誤的可能性。 TargetTypeNames 要求每個專案都完整，並指定其元件名稱。此外，使用多個並行版本時，版本號碼也必須附加至目標類型名稱。

使用 TargetTypes時，您可以使用下列 C# 程式代碼示範的方式，將每個物件新增 (， MyClass) 至清單。

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

適用於

共用方式為

XmlMessageFormatter 建構函式

定義

多載

XmlMessageFormatter()

備註

適用於

XmlMessageFormatter(String[])

參數

例外狀況

範例

備註

適用於

XmlMessageFormatter(Type[])

參數

例外狀況

備註

適用於

其他資源