Was this page helpful?
Your feedback about this content is important. Let us know what you think.
Additional feedback?
1500 characters remaining
TargetTypes Property
Collapse the table of content
Expand the table of content

XmlMessageFormatter.TargetTypes Property

Specifies the set of possible types that will be deserialized by the formatter from the message provided.

[Visual Basic]
Public Property TargetTypes As Type ()
[C#]
public Type[] TargetTypes {get; set;}
[C++]
public: __property Type* get_TargetTypes();
public: __property void set_TargetTypes(Type*[]);
[JScript]
public function get TargetTypes() : Type[];
public function set TargetTypes(Type[]);

Property Value

An array of type Type that specifies the types of objects to deserialize from the message body when reading the message.

Exceptions

Exception Type Condition
ArgumentNullException The TargetTypes property is a null reference (Nothing in Visual Basic).

Remarks

Both the TargetTypeNames and TargetTypes properties tell the formatter what schemas to attempt to match when deserializing a message. This allows the formatter to interpret the message body.

The instance serialized in the message body must comply with one of the schemas represented in the type array. When you read the message using the Receive method, the method creates object of the type that corresponds to the schema identied and reads the message body into it.

Only one of the two properties needs to be set when reading from the queue, but you can set both. The set of types is the combined set from the two properties. The decision of which property to use is specific to your application. 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 when the message is read.

Note   The target types are only required when reading from the queue. The TargetTypeNames and TargetTypes properties do not need to be set to write to the queue.

When specifying TargetTypes rather than TargetTypeNames, type existence is checked at compile time rather than read time, reducing possibility for error.

When using TargetTypes, you can add each object (say, MyClass) to the list in a way demonstrated by the C# code TargetTypes = new Type[]{typeof(MyClass), typeof

(MyOtherClass)};.

Example

[Visual Basic, C#, C++] The following example sends and receives a message containing an order to and from a queue.

[Visual Basic] 
Imports System
Imports System.Messaging
Imports System.Drawing
Imports System.IO


Namespace MyProject
    _
   
   ' 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 'Order
    _
   
   '/ <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 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 'Main
      
      
      '**************************************************
      ' 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 'CreateQueue
       
      
      '**************************************************
      ' 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 'SendMessage
      
      
      
      '**************************************************
      ' 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(MyProject.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()))
         
         Catch
         ' Handle Message Queuing exceptions.
         
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         End Try
         
         ' Catch other exceptions as necessary.
         Return
      End Sub 'ReceiveMessage
   End Class 'MyNewQueue
End Namespace 'MyProject

[C#] 
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;
        }
    }
}

[C++] 
#using <mscorlib.dll>
#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;


__gc class Order 
{
public:
    int orderId;
public:
    DateTime orderTime;
};    

__gc 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);
        }
    }

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(S".\\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;
    }

public:
    void ReceiveMessage() 
    {
        // Connect to the a queue on the local computer.
        MessageQueue* myQueue = new MessageQueue(S".\\myQueue");

        // Set the formatter to indicate body contains an Order.
        Type* p __gc[] = new Type*[1];
        p[0] = __typeof(Order);
        myQueue->Formatter = new XmlMessageFormatter( p );

        try 
        {
            // Receive and format the message. 
            Message* myMessage = myQueue->Receive(); 
            Order* myOrder = dynamic_cast<Order*>(myMessage->Body);

            // Display message information.
            Console::WriteLine(S"Order ID: {0}", __box(myOrder->orderId));
            Console::WriteLine(S"Sent: {0}", __box(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 = new MyNewQueue();

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

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

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

    return 0;
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

.NET Framework Security: 

See Also

XmlMessageFormatter Class | XmlMessageFormatter Members | System.Messaging Namespace | TargetTypeNames | CanRead | XmlMessageFormatter

Show:
© 2015 Microsoft