Was this page helpful?
Your feedback about this content is important. Let us know what you think.
Additional feedback?
1500 characters remaining
Export (0) Print
Expand All

XmlSerializer Constructor (Type, array<Type>)

Initializes a new instance of the XmlSerializer class that can serialize objects of the specified type into XML documents, and deserialize XML documents into object of a specified type. If a property or field returns an array, the extraTypes parameter specifies objects that can be inserted into the array.

Namespace:  System.Xml.Serialization
Assemblies:   System.Xml.XmlSerializer (in System.Xml.XmlSerializer.dll)
  System.Xml (in System.Xml.dll)

public:
XmlSerializer(
	Type^ type, 
	array<Type^>^ extraTypes
)

Parameters

type
Type: System::Type

The type of the object that this XmlSerializer can serialize.

extraTypes
Type: array<System::Type>

A Type array of additional object types to serialize.

By default, if a public property or field returns an object, or array of objects, the object types are automatically serialized. However, if a class contains a field or property that returns an array of type Object, any object can be inserted into that array. In that case, the XmlSerializer must be instructed to expect all the possible object types that are inserted into the Object array. To do this, use the extraTypes parameter to specify the extra object types to serialize or deserialize.

You can also use the extraTypes parameter to specify types derived from a base class. For example, suppose a base class named Phone exists, and a class named InternationalPhone derives from it. Use the extraTypes parameter to specify the derived type as well.

The following example serializes an instance of a class that contains a public field that returns an array of objects. The extraTypes parameter of the XmlSerializer constructor specifies the types of the objects that can be serialized in the array.

#using <System.Xml.dll>
#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
using namespace System::Xml::Serialization;
ref class Address;
ref class Phone;

// This defines the object that will be serialized. 
public ref class Teacher
{
public:
   String^ Name;
   Teacher(){}

   /* Note that the Info field returns an array of objects.
         Any object can be added to the array by adding the
         object type to the array passed to the extraTypes argument. */

   [XmlArray(ElementName="ExtraInfo",IsNullable=true)]
   array<Object^>^Info;
   Phone^ PhoneInfo;
};


// This defines one of the extra types to be included. 
public ref class Address
{
public:
   String^ City;
   Address(){}

   Address( String^ city )
   {
      City = city;
   }
};

// Another extra type to include. 
public ref class Phone
{
public:
   String^ PhoneNumber;
   Phone(){}

   Phone( String^ phoneNumber )
   {
      PhoneNumber = phoneNumber;
   }
};

// Another type, derived from Phone 
public ref class InternationalPhone: public Phone
{
public:
   String^ CountryCode;
   InternationalPhone(){}

   InternationalPhone( String^ countryCode )
   {
      CountryCode = countryCode;
   }
};

public ref class Run
{
public:
   static void main()
   {
      Run^ test = gcnew Run;
      test->SerializeObject( "Teacher.xml" );
      test->DeserializeObject( "Teacher.xml" );
   }

private:
   void SerializeObject( String^ filename )
   {
      // Writing the file requires a TextWriter.
      TextWriter^ myStreamWriter = gcnew StreamWriter( filename );

      // Create a Type array. 
      array<Type^>^extraTypes = gcnew array<Type^>(3);
      extraTypes[ 0 ] = Address::typeid;
      extraTypes[ 1 ] = Phone::typeid;
      extraTypes[ 2 ] = InternationalPhone::typeid;

      // Create the XmlSerializer instance.
      XmlSerializer^ mySerializer = gcnew XmlSerializer( Teacher::typeid,extraTypes );
      Teacher^ teacher = gcnew Teacher;
      teacher->Name = "Mike";

      // Add extra types to the Teacher object 
      array<Object^>^info = gcnew array<Object^>(2);
      info[ 0 ] = gcnew Address( "Springville" );
      info[ 1 ] = gcnew Phone( "555-0100" );
      teacher->Info = info;
      teacher->PhoneInfo = gcnew InternationalPhone( "000" );
      mySerializer->Serialize( myStreamWriter, teacher );
      myStreamWriter->Close();
   }

   void DeserializeObject( String^ filename )
   {
      // Create a Type array. 
      array<Type^>^extraTypes = gcnew array<Type^>(3);
      extraTypes[ 0 ] = Address::typeid;
      extraTypes[ 1 ] = Phone::typeid;
      extraTypes[ 2 ] = InternationalPhone::typeid;

      // Create the XmlSerializer instance.
      XmlSerializer^ mySerializer = gcnew XmlSerializer( Teacher::typeid,extraTypes );

      // Reading a file requires a FileStream.
      FileStream^ fs = gcnew FileStream( filename,FileMode::Open );
      Teacher^ teacher = dynamic_cast<Teacher^>(mySerializer->Deserialize( fs ));

      // Read the extra information.
      Address^ a = dynamic_cast<Address^>(teacher->Info[ 0 ]);
      Phone^ p = dynamic_cast<Phone^>(teacher->Info[ 1 ]);
      InternationalPhone^ Ip = dynamic_cast<InternationalPhone^>(teacher->PhoneInfo);
      Console::WriteLine( teacher->Name );
      Console::WriteLine( a->City );
      Console::WriteLine( p->PhoneNumber );
      Console::WriteLine( Ip->CountryCode );
   }
};

int main()
{
   Run::main();
}

.NET Framework

Supported in: 4.6, 4.5, 4, 3.5, 3.0, 2.0, 1.1

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

XNA Framework

Supported in: 3.0, 2.0, 1.0

Portable Class Library

Supported in: Portable Class Library

Supported in: Windows Phone 8.1

Supported in: Windows Phone Silverlight 8.1

Supported in: Windows Phone Silverlight 8
Show:
© 2015 Microsoft