This documentation is archived and is not being maintained.

XmlArrayItemAttribute.Type Property

Gets or sets the type allowed in an array.

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

Property Value

A Type that is allowed in the array.

Remarks

Use the Type property to specify an overridden type for a public field or public read/write property value.

If a field or property returns an array of type Object, apply multiple instances of the XmlArrayItemAttribute to the field or property. For each instance, set the Type property to a type of object that can be inserted into the array.

If an array contains only primitive types, you need not apply the XmlArrayItemAttribute. By default, the XmlSerializer will generate a series of elements, each with the same element name, for each value, but the type of each element will be set to the XML Schema data type. For example, the following code:

' Visual Basic code
Public Class Arrays
   Public XSDTypes ()As Object= New Object(){"one", 2, 3.0}
End Class
// C# code
public class MyArray{
   // No XmlArrayItemAttribute is applied. 
   public object[] XSDTypes= new object[]{"one", 2, 3.2};
}

will result in this XML:

<?xml version="1.0" encoding="utf-8"?>
<Arrays xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <XSDTypes>
    <Object xsi:type="xsd:string">one</Object>
    <Object xsi:type="xsd:int">2</Object>
    <Object xsi:type="xsd:double">3</Object>
  </XSDTypes>
</Arrays>

However, if you specify the Type property for each primitive type, the element name for each value will be generated using the .NET type name. For example this code:

' Visual Basic code
Public Class Arrays
   <XmlArrayItem(GetType(String)), _
   XmlArrayItem(GetType(Integer)), _
   XmlArrayItem(GetType(Double))> _
   Public PrimitiveTypes () As Object = New Object(){"one", 2, 3.0}
End Class
// C# code
public class Arrays{
   [XmlArrayItem(typeof(string))]
   [XmlArrayItem(typeof(int))]
   [XmlArrayItem(typeof(double))]
   public object [] PrimitiveTypes = new object[]{"one", 2, 3.0};
}

will result in this XML:

<?xml version="1.0" encoding="utf-8"?>
<Arrays xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <PrimitiveTypes>
    <string>one</string>
    <int>2</int>
    <double>3</double>
  </PrimitiveTypes>
</Arrays>

Example

[Visual Basic, C#, C++] The following example serializes an array of objects. The field that returns the array is attributed with two XmlArrayItemAttribute instances. Each instance instructs the XmlSerializer to accept the specified Type in the array.

[Visual Basic] 
Imports System
Imports System.IO
Imports System.Xml.Serialization



Public Class Group
    ' The Type property instructs the XmlSerializer to accept both
    ' the Person and Manager types in the array. 
    <XmlArrayItem(Type := GetType(Manager)), _
     XmlArrayItem(Type := GetType(Person))> _
    Public Staff() As Person
        
End Class 'Group


Public Class Person
    Public Name As String
End Class 


Public Class Manager
    Inherits Person
    Public Rank As Integer
End Class 


Public Class Run
    
    Public Shared Sub Main()
        Dim test As New Run()
        test.SerializeOrder("TypeEx.xml")
    End Sub 
        
    
    Public Sub SerializeOrder(filename As String)
        ' Creates an XmlSerializer.
        Dim xSer As New XmlSerializer(GetType(Group))
        
        ' Creates the Group object, and two array items.
        Dim myGroup As New Group()
        
        Dim p1 As New Person()
        p1.Name = "Jacki"
        Dim p2 As New Manager()
        
        p2.Name = "Megan"
        p2.Rank = 2
        
        Dim myStaff() As Person =  {p1, p2}
        myGroup.Staff = myStaff
        
        ' Serializes the object, and closes the StreamWriter.
        Dim writer As New StreamWriter(filename)
        xSer.Serialize(writer, myGroup)
    End Sub 
End Class 'Run

[C#] 
using System;
using System.IO;
using System.Xml.Serialization;

public class Group
{
   /* The Type property instructs the XmlSerializer to accept both
   the Person and Manager types in the array. */
   [XmlArrayItem(Type = typeof(Manager)),
   XmlArrayItem(Type=typeof(Person))]
   public Person[]Staff;
}

public class Person
{
   public string Name;
}

public class Manager:Person
{
   public int Rank;
}

public class Run 
{
   public static void Main()
   {
      Run test = new Run();
      test.SerializeOrder("TypeEx.xml");
   }


   public void SerializeOrder(string filename)
   {
      // Creates an XmlSerializer.
      XmlSerializer xSer = 
      new XmlSerializer(typeof(Group));

      // Creates the Group object, and two array items.
      Group myGroup = new Group();

      Person p1 = new Person();
      p1.Name = "Jacki";
      Manager p2 = new Manager();

      p2.Name = "Megan";
      p2.Rank = 2;

      Person [] myStaff = {p1,p2};
      myGroup.Staff = myStaff;

      // Serializes the object, and closes the StreamWriter.
      TextWriter writer = new StreamWriter(filename);
      xSer.Serialize(writer, myGroup);
   }
}

[C++] 
#using <mscorlib.dll>
#using <System.Xml.dll>
#using <System.dll>
using namespace System;
using namespace System::IO;
using namespace System::Xml::Serialization;

public __gc class Person
{
public:
   String* Name;
};

public __gc class Manager:public Person
{
public:
   int Rank;
};

public __gc class Group
{
   /* The Type property instructs the XmlSerializer to accept both
   the Person and Manager types in the array. */
public:
   [XmlArrayItem(Type = __typeof(Manager)),
      XmlArrayItem(Type=__typeof(Person))]
   Person* Staff[];
};

void SerializeOrder(String* filename)
{
   // Creates an XmlSerializer.
   XmlSerializer* xSer = 
      new XmlSerializer(__typeof(Group));

   // Creates the Group object, and two array items.
   Group* myGroup = new Group();

   Person* p1 = new Person();
   p1->Name = S"Jacki";
   Manager* p2 = new Manager();

   p2->Name = S"Megan";
   p2->Rank = 2;

   Person* myStaff[] = {p1,p2};
   myGroup->Staff = myStaff;

   // Serializes the object, and closes the StreamWriter.
   TextWriter* writer = new StreamWriter(filename);
   xSer->Serialize(writer, myGroup);
}

int main()
{
   SerializeOrder(S"TypeEx.xml");
}

[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 Compact Framework

See Also

XmlArrayItemAttribute Class | XmlArrayItemAttribute Members | System.Xml.Serialization Namespace

Show: