XmlSerializer コンストラクタとは何？わかりやすく解説 Weblio辞書

XmlSerializer コンストラクタ (Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String)

Object 型のオブジェクトを XML ドキュメントインスタンスにシリアル化したり、XML ドキュメントインスタンスを Object 型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。シリアル化される各オブジェクトはそれ自体がクラスのインスタンスを含むことができ、それをこのオーバーロードによって他のクラスでオーバーライドします。このオーバーロードでは、すべての XML 要素の既定の名前空間、および XML ルート要素として使用するクラスも指定します。

名前空間: System.Xml.Serialization
アセンブリ: System.Xml (system.xml.dll 内)
構文

Visual Basic (宣言)

Public Sub New ( _
    type As Type, _
    overrides As XmlAttributeOverrides, _
    extraTypes As Type(), _
    root As XmlRootAttribute, _
    defaultNamespace As String _
)

Visual Basic (使用法)

Dim type As Type
Dim overrides As XmlAttributeOverrides
Dim extraTypes As Type()
Dim root As XmlRootAttribute
Dim defaultNamespace As String

Dim instance As New XmlSerializer(type,
 overrides, extraTypes, root, defaultNamespace)

public XmlSerializer (
    Type type,
    XmlAttributeOverrides overrides,
    Type[] extraTypes,
    XmlRootAttribute root,
    string defaultNamespace
)

C++

public:
XmlSerializer (
    Type^ type, 
    XmlAttributeOverrides^ overrides, 
    array<Type^>^ extraTypes, 
    XmlRootAttribute^ root, 
    String^ defaultNamespace
)

public XmlSerializer (
    Type type, 
    XmlAttributeOverrides overrides, 
    Type[] extraTypes, 
    XmlRootAttribute root, 
    String defaultNamespace
)

JScript

public function XmlSerializer (
    type : Type, 
    overrides : XmlAttributeOverrides, 
    extraTypes : Type[], 
    root : XmlRootAttribute, 
    defaultNamespace : String
)

パラメータ

type: XmlSerializer がシリアル化できるオブジェクトの型。

overrides: type パラメータで指定されたクラスの動作を拡張またはオーバーライドする XmlAttributeOverrides。

extraTypes: シリアル化する追加のオブジェクト型の Type 配列。

root: XML ルート要素プロパティを定義する XmlRootAttribute。

defaultNamespace: XML ドキュメント内のすべての XML 要素の既定の名前空間。

解説

overrides パラメータにより、基本クラスの動作を拡張またはオーバーライドするクラスをシリアル化する XmlSerializer を作成できます。たとえば DLL を指定すると、この DLL に含まれるクラスを継承または拡張するクラスを作成できます。このようなクラスをシリアル化するには、XmlSerializer の構築時に XmlAttributeOverrides クラスのインスタンスを使用する必要があります。詳細については、XmlAttributeOverrides のトピックを参照してください。

既定では、パブリックプロパティまたはパブリックフィールドがオブジェクトまたはオブジェクトの配列を返したときには、それらのオブジェクトの型が自動的にシリアル化されます。ただし、Object 型の配列を返すフィールドまたはプロパティがクラスに含まれている場合は、すべてのオブジェクトが配列に挿入されます。この場合、XmlSerializer に対して、Object 配列に挿入される可能性のあるすべてのオブジェクトの型を通知しておく必要があります。この場合は、extraTypes パラメータを使用して、シリアル化または逆シリアル化する追加のオブジェクト型を指定する必要があります。

XML ドキュメントのルート要素には、他のすべての要素が入っています。既定では、type パラメータで指定されたオブジェクトがルート要素としてシリアル化されます。ルート要素の XML 要素名などのプロパティは、type オブジェクトから取得されます。ただし、root パラメータを使用すると、異なる名前空間や要素名などを設定するために使用できる XmlRootAttribute オブジェクトを指定して、既定のオブジェクトの情報を置き換えることができます。

defaultName パラメータを使用して、XmlSerializer が生成するすべての XML 要素の既定の名前空間を指定します。

使用例

DLL に定義されているクラスのインスタンスをシリアル化するため、そのクラス内のパブリックメンバをオーバーライドする例を次に示します。この例では、追加する型の配列、すべての XML 要素の既定の名前空間、および XML ルート要素の情報を提供するために使用するクラスも指定しています。この例では、先頭部分のコードが HighSchool という名前の DLL にコンパイル済みであることを前提としています。

Visual Basic

'Beginning of the HighSchool.dll 
Imports System
Imports System.IO
Imports System.Xml
Imports System.Xml.Serialization
Imports Microsoft.VisualBasic
' Imports HighSchool

Namespace HighSchool

    Public Class Student
        Public Name As String
        Public ID As Integer
    End Class 'Student


    Public Class ClassRoom
        Public Students() As Student
    End Class 'ClassRoom
End Namespace 'HighSchool

Namespace College
    Public Class Graduate
        Inherits HighSchool.Student

        Public Sub New()
        End Sub 'New
        ' Add a new field named University.
        Public University As String
        ' Use extra types to use this field.
        Public Info() As Object
    End Class 'Graduate


    Public Class Address
        Public City As String
    End Class 'Address


    Public Class Phone
        Public Number As String
    End Class 'Phone


    Public Class Run

        Public Shared Sub
 Main()
            Dim test As New
 Run()
            test.WriteOverriddenAttributes("College.xml")
            test.ReadOverriddenAttributes("College.xml")
        End Sub 'Main


        Private Sub WriteOverriddenAttributes(ByVal
 filename As String)
            ' Writing the file requires a TextWriter.
            Dim myStreamWriter As New
 StreamWriter(filename)
            ' Create an XMLAttributeOverrides class.
            Dim attrOverrides As New
 XmlAttributeOverrides()
            ' Create the XmlAttributes class.
            Dim attrs As New
 XmlAttributes()
            ' Override the Student class. "Alumni" is the
 name
            ' of the overriding element in the XML output. 

            Dim attr As New
 XmlElementAttribute("Alumni", GetType(Graduate))
            ' Add the XmlElementAttribute to the collection of
            ' elements in the XmlAttributes object. 
            attrs.XmlElements.Add(attr)
            ' Add the XmlAttributes to the XmlAttributeOverrides.
            ' "Students" is the name being overridden. 
            attrOverrides.Add(GetType(HighSchool.ClassRoom), "Students",
 attrs)

            ' Create array of extra types.
            Dim extraTypes(1) As Type
            extraTypes(0) = GetType(Address)
            extraTypes(1) = GetType(Phone)

            ' Create an XmlRootAttribute.
            Dim root As New
 XmlRootAttribute("Graduates")

            ' Create the XmlSerializer with the
            ' XmlAttributeOverrides object. 
            Dim mySerializer As New
 XmlSerializer(GetType(HighSchool.ClassRoom), _
                attrOverrides, extraTypes, root, "http://www.microsoft.com")

            Dim oMyClass As New
 HighSchool.ClassRoom()

            Dim g1 As New
 Graduate()
            g1.Name = "Jacki"
            g1.ID = 1
            g1.University = "Alma"

            Dim g2 As New
 Graduate()
            g2.Name = "Megan"
            g2.ID = 2
            g2.University = "CM"

            Dim myArray As HighSchool.Student()
 = {g1, g2}

            oMyClass.Students = myArray

            ' Create extra information.
            Dim a1 As New
 Address()
            a1.City = "Ionia"
            Dim a2 As New
 Address()
            a2.City = "Stamford"
            Dim p1 As New
 Phone()
            p1.Number = "555-0101"
            Dim p2 As New
 Phone()
            p2.Number = "555-0100"

            Dim o1() As Object
 = {a1, p1}
            Dim o2() As Object
 = {a2, p2}

            g1.Info = o1
            g2.Info = o2
            mySerializer.Serialize(myStreamWriter, oMyClass)
            myStreamWriter.Close()
        End Sub 'WriteOverriddenAttributes


        Private Sub ReadOverriddenAttributes(ByVal
 filename As String)
            ' The majority of the code here is the same as that in the
            ' WriteOverriddenAttributes method. Because the XML being
 read
            ' doesn't conform to the schema defined by the DLL, the
            ' XMLAttributesOverrides must be used to create an
            ' XmlSerializer instance to read the XML document.

            Dim attrOverrides As New
 XmlAttributeOverrides()
            Dim attrs As New
 XmlAttributes()
            Dim attr As New
 XmlElementAttribute("Alumni", GetType(Graduate))
            attrs.XmlElements.Add(attr)
            attrOverrides.Add(GetType(HighSchool.ClassRoom), "Students",
 attrs)

            Dim extraTypes(1) As Type
            extraTypes(0) = GetType(Address)
            extraTypes(1) = GetType(Phone)

            Dim root As New
 XmlRootAttribute("Graduates")

            Dim readSerializer As New
 XmlSerializer(GetType(HighSchool.ClassRoom), _
                attrOverrides, extraTypes, root, "http://www.microsoft.com")

            ' A FileStream object is required to read the file. 
            Dim fs As New
 FileStream(filename, FileMode.Open)

            Dim oMyClass As HighSchool.ClassRoom
            oMyClass = CType(readSerializer.Deserialize(fs), HighSchool.ClassRoom)

            ' Here is the difference between reading and writing an
            ' XML document: You must declare an object of the derived
            ' type (Graduate) and cast the Student instance to it.
            Dim g As Graduate
            Dim a As Address
            Dim p As Phone
            Dim grad As Graduate
            For Each grad In
 oMyClass.Students
                g = CType(grad, Graduate)
                Console.Write((g.Name & ControlChars.Tab))
                Console.Write((g.ID & ControlChars.Tab))
                Console.Write((g.University & ControlChars.Cr))
                a = CType(g.Info(0), Address)
                Console.WriteLine(a.City)
                p = CType(g.Info(1), Phone)
                Console.WriteLine(p.Number)
            Next grad
        End Sub 'ReadOverriddenAttributes
    End Class 'Run
End Namespace 'College

// Beginning of the HighSchool.dll 

namespace HighSchool
{
   public class Student
   {
      public string Name;
      public int ID;
   }
    
   public class MyClass
   {
      public Student[] Students;
   }
}

namespace College
   {
   using System;
   using System.IO;
   using System.Xml;
   using System.Xml.Serialization; 
   using HighSchool;

    public class Graduate:HighSchool.Student
    {
       public Graduate(){}
       // Add a new field named University.
       public string University;
       // Use extra types to use this field.
       public object[]Info;
    }
 
    public class Address
    {
       public string City;
    }
 
    public class Phone
    {
       public string Number;
    }
    
   public class Run
   {
      public static void
 Main()
      {
         Run test = new Run();
         test.WriteOverriddenAttributes("College.xml");
         test.ReadOverriddenAttributes("College.xml");
      }
 
      private void WriteOverriddenAttributes(string
 filename)
      {
         // Writing the file requires a TextWriter.
         TextWriter myStreamWriter = new StreamWriter(filename);
         // Create an XMLAttributeOverrides class.
         XmlAttributeOverrides attrOverrides = 
         new XmlAttributeOverrides();
         // Create the XmlAttributes class.
         XmlAttributes attrs = new XmlAttributes();
         /* Override the Student class. "Alumni" is
 the name
         of the overriding element in the XML output. */

         XmlElementAttribute attr = 
         new XmlElementAttribute("Alumni", typeof(Graduate));
         /* Add the XmlElementAttribute to the collection of
         elements in the XmlAttributes object. */
         attrs.XmlElements.Add(attr);
         /* Add the XmlAttributes to the XmlAttributeOverrides. 
         "Students" is the name being overridden. */
         attrOverrides.Add(typeof(HighSchool.MyClass), 
         "Students", attrs);
 
         // Create array of extra types.
         Type [] extraTypes = new Type[2];
         extraTypes[0]=typeof(Address);
         extraTypes[1]=typeof(Phone);
 
         // Create an XmlRootAttribute.
         XmlRootAttribute root = new XmlRootAttribute("Graduates");
          
         /* Create the XmlSerializer with the 
         XmlAttributeOverrides object. */
         XmlSerializer mySerializer = new XmlSerializer
         (typeof(HighSchool.MyClass), attrOverrides, extraTypes,
         root, "http://www.microsoft.com");
 
         MyClass myClass= new MyClass();

         Graduate g1 = new Graduate();
         g1.Name = "Jacki";
         g1.ID = 1;
         g1.University = "Alma";

         Graduate g2 = new Graduate();
         g2.Name = "Megan";
         g2.ID = 2;
         g2.University = "CM";

         Student[] myArray = {g1,g2};

         myClass.Students = myArray;
 
         // Create extra information.
         Address a1 = new Address();
         a1.City = "Ionia";
         Address a2 = new Address();
         a2.City = "Stamford";
         Phone p1 = new Phone();
         p1.Number = "555-0101";
         Phone p2 = new Phone();
         p2.Number = "555-0100";
 
         Object[]o1 = new Object[2]{a1, p1};
         Object[]o2 = new Object[2]{a2,p2};
 
         g1.Info = o1;
         g2.Info = o2;
         mySerializer.Serialize(myStreamWriter,myClass);
         myStreamWriter.Close();
      }

      private void ReadOverriddenAttributes(string
 filename)
      {
         /* The majority of the code here is the same as that in
 the
         WriteOverriddenAttributes method. Because the XML being read
         doesn't conform to the schema defined by the DLL, the
         XMLAttributesOverrides must be used to create an 
         XmlSerializer instance to read the XML document.*/
          
         XmlAttributeOverrides attrOverrides = new 
         XmlAttributeOverrides();
         XmlAttributes attrs = new XmlAttributes();
         XmlElementAttribute attr = 
         new XmlElementAttribute("Alumni", typeof(Graduate));
         attrs.XmlElements.Add(attr);
         attrOverrides.Add(typeof(HighSchool.MyClass), 
         "Students", attrs);

         Type [] extraTypes = new Type[2];
         extraTypes[0] = typeof(Address);
         extraTypes[1] = typeof(Phone);
 
         XmlRootAttribute root = new XmlRootAttribute("Graduates");
          
         XmlSerializer readSerializer = new XmlSerializer
         (typeof(HighSchool.MyClass), attrOverrides, extraTypes,
         root, "http://www.microsoft.com");

         // A FileStream object is required to read the file. 
         FileStream fs = new FileStream(filename, FileMode.Open);
          
         MyClass myClass;
         myClass = (MyClass) readSerializer.Deserialize(fs);

         /* Here is the difference between reading and writing an 
         XML document: You must declare an object of the derived 
         type (Graduate) and cast the Student instance to it.*/
         Graduate g;
         Address a;
         Phone p;
         foreach(Graduate grad in myClass.Students)
         {
            g = (Graduate) grad;
            Console.Write(g.Name + "\t");
            Console.Write(g.ID + "\t");
            Console.Write(g.University + "\n");
            a = (Address) g.Info[0];
            Console.WriteLine(a.City);
            p = (Phone) g.Info[1];
            Console.WriteLine(p.Number);
         }
      }
   }
}

C++

// Beginning of the HighSchool.dll 
#using <System.Xml.dll>
#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
using namespace System::Xml::Serialization;

namespace HighSchool
{
   public ref class Student
   {
   public:
      String^ Name;
      int ID;
   };

   public ref class MyClass
   {
   public:
      array<Student^>^Students;
   };
}

namespace College
{

using namespace HighSchool;
   public ref class Graduate: public
 HighSchool::Student
   {
   public:
      Graduate(){}

      // Add a new field named University.
      String^ University;

      // Use extra types to use this field.
      array<Object^>^Info;
   };

   public ref class Address
   {
   public:
      String^ City;
   };

   public ref class Phone
   {
   public:
      String^ Number;
   };

   public ref class Run
   {
   public:
      static void main()
      {
         Run^ test = gcnew Run;
         test->WriteOverriddenAttributes( "College.xml" );
         test->ReadOverriddenAttributes( "College.xml" );
      }

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

         // Create an XMLAttributeOverrides class.
         XmlAttributeOverrides^ attrOverrides = gcnew XmlAttributeOverrides;

         // Create the XmlAttributes class.
         XmlAttributes^ attrs = gcnew XmlAttributes;

         /* Override the Student class. "Alumni" is
 the name
               of the overriding element in the XML output. */
         XmlElementAttribute^ attr = gcnew XmlElementAttribute( "Alumni",Graduate::typeid
 );

         /* Add the XmlElementAttribute to the collection of
               elements in the XmlAttributes object. */
         attrs->XmlElements->Add( attr );

         /* Add the XmlAttributes to the XmlAttributeOverrides. 
               "Students" is the name being overridden. */
         attrOverrides->Add( HighSchool::MyClass::typeid, "Students",
 attrs );

         // Create array of extra types.
         array<Type^>^extraTypes = gcnew array<Type^>(2);
         extraTypes[ 0 ] = Address::typeid;
         extraTypes[ 1 ] = Phone::typeid;

         // Create an XmlRootAttribute.
         XmlRootAttribute^ root = gcnew XmlRootAttribute( "Graduates" );

         /* Create the XmlSerializer with the 
               XmlAttributeOverrides object. */
         XmlSerializer^ mySerializer = gcnew XmlSerializer( HighSchool::MyClass::typeid,attrOverrides,extraTypes,root,"http://www.microsoft.com"
 );
         MyClass ^ myClass = gcnew MyClass;
         Graduate^ g1 = gcnew Graduate;
         g1->Name = "Jacki";
         g1->ID = 1;
         g1->University = "Alma";
         Graduate^ g2 = gcnew Graduate;
         g2->Name = "Megan";
         g2->ID = 2;
         g2->University = "CM";
         array<Student^>^myArray = {g1,g2};
         myClass->Students = myArray;

         // Create extra information.
         Address^ a1 = gcnew Address;
         a1->City = "Ionia";
         Address^ a2 = gcnew Address;
         a2->City = "Stamford";
         Phone^ p1 = gcnew Phone;
         p1->Number = "555-0101";
         Phone^ p2 = gcnew Phone;
         p2->Number = "555-0100";
         array<Object^>^o1 = {a1,p1};
         array<Object^>^o2 = {a2,p2};
         g1->Info = o1;
         g2->Info = o2;
         mySerializer->Serialize( myStreamWriter, myClass );
         myStreamWriter->Close();
      }

      void ReadOverriddenAttributes( String^ filename )
      {
         /* The majority of the code here is the same as that in
 the
               WriteOverriddenAttributes method. Because the XML being read
               doesn't conform to the schema defined by the DLL, the
               XMLAttributesOverrides must be used to create an 
               XmlSerializer instance to read the XML document.*/
         XmlAttributeOverrides^ attrOverrides = gcnew XmlAttributeOverrides;
         XmlAttributes^ attrs = gcnew XmlAttributes;
         XmlElementAttribute^ attr = gcnew XmlElementAttribute( "Alumni",Graduate::typeid
 );
         attrs->XmlElements->Add( attr );
         attrOverrides->Add( HighSchool::MyClass::typeid, "Students",
 attrs );
         array<Type^>^extraTypes = gcnew array<Type^>(2);
         extraTypes[ 0 ] = Address::typeid;
         extraTypes[ 1 ] = Phone::typeid;
         XmlRootAttribute^ root = gcnew XmlRootAttribute( "Graduates" );
         XmlSerializer^ readSerializer = gcnew XmlSerializer( HighSchool::MyClass::typeid,attrOverrides,extraTypes,root,"http://www.microsoft.com"
 );

         // A FileStream object is required to read the file. 
         FileStream^ fs = gcnew FileStream( filename,FileMode::Open );
         MyClass ^ myClass;
         myClass = dynamic_cast<MyClass^>(readSerializer->Deserialize( fs
 ));
         
         /* Here is the difference between reading and writing an 
               XML document: You must declare an object of the derived 
               type (Graduate) and cast the Student instance to it.*/
         Graduate^ g;
         Address^ a;
         Phone^ p;
         System::Collections::IEnumerator^ myEnum = myClass->Students->GetEnumerator();
         while ( myEnum->MoveNext() )
         {
            Graduate^ grad = safe_cast<Graduate^>(myEnum->Current);
            g = dynamic_cast<Graduate^>(grad);
            Console::Write( "{0}\t", g->Name );
            Console::Write( "{0}\t", g->ID );
            Console::Write( "{0}\n", g->University );
            a = dynamic_cast<Address^>(g->Info[ 0 ]);
            Console::WriteLine( a->City );
            p = dynamic_cast<Phone^>(g->Info[ 1 ]);
            Console::WriteLine( p->Number );
         }
      }
   };
}

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

package College;

import System.*;
import System.IO.*;
import System.Xml.*;
import System.Xml.Serialization.*;
import HighSchool.*;
public class Graduate extends HighSchool.Student
{
    public Graduate()
    {
    } //Graduate
    // Add a new field named University.
    public String university;
    // Use extra types to use this field.
    public Object info[];
} //Graduate

public class Address
{
    public String city;
} //Address

public class Phone
{
    public String number;
} //Phone

public class Run
{
    public static void main(String[]
 args)
    {
        Run test = new Run();
        test.WriteOverriddenAttributes("College.xml");
        test.ReadOverriddenAttributes("College.xml");
    } //main

    private void WriteOverriddenAttributes(String
 filename)
    {
        // Writing the file requires a TextWriter.
        TextWriter myStreamWriter = new StreamWriter(filename);

        // Create an XMLAttributeOverrides class.
        XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();

        // Create the XmlAttributes class.
        XmlAttributes attrs = new XmlAttributes();

        /* Override the Student class. "Alumni" is the
 name
           of the overriding element in the XML output. */
        XmlElementAttribute attr =
            new XmlElementAttribute("Alumni", Graduate.class.ToType());

        /* Add the XmlElementAttribute to the collection of
           elements in the XmlAttributes object. */
        attrs.get_XmlElements().Add(attr);

        /* Add the XmlAttributes to the XmlAttributeOverrides. 
          "Students" is the name being overridden. */
        attrOverrides.Add(HighSchool.MyClass.class.ToType(), "students",
 attrs);

        // Create array of extra types.
        Type extraTypes[] = new Type[2];
        extraTypes.set_Item(0, Address.class.ToType());
        extraTypes.set_Item(1, Phone.class.ToType());

        // Create an XmlRootAttribute.
        XmlRootAttribute root = new XmlRootAttribute("Graduates");

        /* Create the XmlSerializer with the 
           XmlAttributeOverrides object. */
        XmlSerializer mySerializer =
            new XmlSerializer(HighSchool.MyClass.class.ToType(),
 attrOverrides,
            extraTypes, root, "http://www.microsoft.com");
        MyClass myClass = new MyClass();
        
        Graduate g1 = new Graduate();
        g1.name = "Jacki";
        g1.iD = 1;
        g1.university = "Alma";

        Graduate g2 = new Graduate();
        g2.name = "Megan";
        g2.iD = 2;
        g2.university = "CM";

        Student myArray[] =  { g1, g2 };
        myClass.students = myArray;

        // Create extra information.
        Address a1 = new Address();
        a1.city = "Ionia";

        Address a2 = new Address();
        a2.city = "Stamford";

        Phone p1 = new Phone();
        p1.number = "000-0000";

        Phone p2 = new Phone();
        p2.number = "555-0100";

        Object o1[] = new Object[] { a1, p1 };
        Object o2[] = new Object[] { a2, p2 };

        g1.info = o1;
        g2.info = o2;
        mySerializer.Serialize(myStreamWriter, myClass);
        myStreamWriter.Close();
    } //WriteOverriddenAttributes

    private void ReadOverriddenAttributes(String
 filename)
    {
        /* The majority of the code here is the same as that in
 the
           WriteOverriddenAttributes method. Because the XML being read
           doesn't conform to the schema defined by the DLL, the
           XMLAttributesOverrides must be used to create an 
           XmlSerializer instance to read the XML document.*/
        XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();
        XmlAttributes attrs = new XmlAttributes();
        XmlElementAttribute attr =
            new XmlElementAttribute("Alumni", Graduate.class.ToType());

        attrs.get_XmlElements().Add(attr);
        attrOverrides.Add(HighSchool.MyClass.class.ToType(), "students",
 attrs);

        Type extraTypes[] = new Type[2];
        extraTypes.set_Item(0, Address.class.ToType());
        extraTypes.set_Item(1, Phone.class.ToType());

        XmlRootAttribute root = new XmlRootAttribute("Graduates");
        XmlSerializer readSerializer =
            new XmlSerializer(HighSchool.MyClass.class.ToType(),
 attrOverrides,
            extraTypes, root, "http://www.microsoft.com");

        // A FileStream object is required to read the file. 
        FileStream fs = new FileStream(filename, FileMode.Open);
        MyClass myClass;
        myClass = (MyClass)readSerializer.Deserialize(fs);

        /* Here is the difference between reading and writing an 
           XML document: You must declare an object of the derived 
           type (Graduate) and cast the Student instance to it.*/
        Graduate g;
        Address a;
        Phone p;

        for (int iCtr = 0; iCtr < myClass.students.length;
 iCtr++) {
            Graduate grad = (Graduate)myClass.students[iCtr];
            g = (Graduate)grad;
            Console.Write(g.name + "\t");
            Console.Write(g.iD + "\t");
            Console.Write(g.university + "\n");
            a = (Address)g.info[0];
            Console.WriteLine(a.city);
            p = (Phone)g.info[1];
            Console.WriteLine(p.number);
        }
    } //ReadOverriddenAttributes
} //Run

package HighSchool;
// Beginning of the HighSchool.dll 
public class Student
{
    public String name;
    public int iD;
} //Student

public class MyClass
{
    public Student students[];
} //MyClass

プラットフォーム

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0

参照

関連項目
XmlSerializer クラス
XmlSerializer メンバ
System.Xml.Serialization 名前空間
XmlAttributeOverrides クラス
XmlRootAttribute クラス
XmlAttributes クラス
その他の技術情報
XML シリアル化の概要
方法 : XML ストリームの代替要素名を指定する
属性を使用した XML シリアル化の制御
XML シリアル化の例
XML スキーマ定義ツール (Xsd.exe)

XmlSerializer コンストラクタ (Type)

指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。

名前空間: System.Xml.Serialization
アセンブリ: System.Xml (system.xml.dll 内)
構文

Visual Basic (宣言)

Public Sub New ( _
    type As Type _
)

Visual Basic (使用法)

Dim type As Type

Dim instance As New XmlSerializer(type)

public XmlSerializer (
    Type type
)

C++

public:
XmlSerializer (
    Type^ type
)

public XmlSerializer (
    Type type
)

JScript

public function XmlSerializer (
    type : Type
)

パラメータ

type: XmlSerializer がシリアル化できるオブジェクトの型。

解説

通常、アプリケーションでは、XmlSerializer が 1 つの XML インスタンスドキュメントへと変換するクラスが複数定義されています。ただし、XmlSerializer が認識する必要がある型は XML ルート要素を表すクラスの型だけです。XmlSerializer は、自動的にすべての下位クラスインスタンスをシリアル化します。同様に、逆シリアル化に必要なのは XML ルート要素の型だけです。

使用例

Widget という名前のシンプルなオブジェクトをシリアル化する XmlSerializer の構築例を次に示します。この例では、オブジェクトの各種プロパティを設定してから Serialize メソッドを呼び出します。

Visual Basic

Private Sub SerializeObject(ByVal
 filename As String)
    Dim serializer As New
 XmlSerializer(GetType(OrderedItem))
    
    ' Create an instance of the class to be serialized.
    Dim i As New OrderedItem()
    
    ' Set the public property values.
    With i
        .ItemName = "Widget"
        .Description = "Regular Widget"
        .Quantity = 10
        .UnitPrice = CDec(2.3)
    End With
    
    ' Writing the document requires a TextWriter.
    Dim writer As New StreamWriter(filename)
    
    ' Serialize the object, and close the TextWriter.
    serializer.Serialize(writer, i)
    writer.Close()
End Sub


' This is the class that will be serialized.
Public Class OrderedItem
    Public ItemName As String
    Public Description As String
    Public UnitPrice As Decimal
    Public Quantity As Integer
End Class

private void SerializeObject(string
 filename)
{
   XmlSerializer serializer = 
   new XmlSerializer(typeof(OrderedItem));

   // Create an instance of the class to be serialized.
   OrderedItem i = new OrderedItem();

   // Set the public property values.
   i.ItemName = "Widget";
   i.Description = "Regular Widget";
   i.Quantity = 10;
   i.UnitPrice = (decimal) 2.30;

   // Writing the document requires a TextWriter.
   TextWriter writer = new StreamWriter(filename);

   // Serialize the object, and close the TextWriter.
   serializer.Serialize(writer, i);
   writer.Close();
}

// This is the class that will be serialized.
public class OrderedItem
{
   public string ItemName;
   public string Description;
   public decimal UnitPrice;
   public int Quantity;
}

C++

private:
   void SerializeObject( String^ filename )
   {
      XmlSerializer^ serializer =
         gcnew XmlSerializer( OrderedItem::typeid );

      // Create an instance of the class to be serialized.
      OrderedItem^ i = gcnew OrderedItem;

      // Set the public property values.
      i->ItemName = "Widget";
      i->Description = "Regular Widget";
      i->Quantity = 10;
      i->UnitPrice = (Decimal)2.30;

      // Writing the document requires a TextWriter.
      TextWriter^ writer = gcnew StreamWriter( filename );

      // Serialize the object, and close the TextWriter.
      serializer->Serialize( writer, i );
      writer->Close();
   }

public:
   // This is the class that will be serialized.
   ref class OrderedItem
   {
   public:
      String^ ItemName;
      String^ Description;
      Decimal UnitPrice;
      int Quantity;
   };

private void SerializeObject(String filename)
{
    XmlSerializer serializer =
        new XmlSerializer(OrderedItem.class.ToType());

    // Create an instance of the class to be serialized.
    OrderedItem i = new OrderedItem();

    // Set the public property values.
    i.itemName = "Widget";
    i.description = "Regular Widget";
    i.quantity = 10;
    i.unitPrice = Convert.ToDecimal(2.3);

    // Writing the document requires a TextWriter.
    TextWriter writer = new StreamWriter(filename);

    // Serialize the object, and close the TextWriter.
    serializer.Serialize(writer, i);
    writer.Close();
} //SerializeObject

// This is the class that will be serialized.
public class OrderedItem
{
    public String itemName;
    public String description;
    public System.Decimal unitPrice;
    public int quantity;
} //OrderedItem

プラットフォーム

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0

参照

関連項目
XmlSerializer クラス
XmlSerializer メンバ
System.Xml.Serialization 名前空間
Serialize
Deserialize
XmlAttributes クラス
その他の技術情報
XML シリアル化の概要
方法 : XML ストリームの代替要素名を指定する
属性を使用した XML シリアル化の制御
XML シリアル化の例
XML スキーマ定義ツール (Xsd.exe)

XmlSerializer コンストラクタ (XmlTypeMapping)

ある型を別の型に割り当てるオブジェクトを指定して、XmlSerializer クラスのインスタンスを初期化します。

名前空間: System.Xml.Serialization
アセンブリ: System.Xml (system.xml.dll 内)
構文

Visual Basic (宣言)

Public Sub New ( _
    xmlTypeMapping As XmlTypeMapping _
)

Visual Basic (使用法)

Dim xmlTypeMapping As XmlTypeMapping

Dim instance As New XmlSerializer(xmlTypeMapping)

public XmlSerializer (
    XmlTypeMapping xmlTypeMapping
)

C++

public:
XmlSerializer (
    XmlTypeMapping^ xmlTypeMapping
)

public XmlSerializer (
    XmlTypeMapping xmlTypeMapping
)

JScript

public function XmlSerializer (
    xmlTypeMapping : XmlTypeMapping
)

パラメータ

xmlTypeMapping: 1 つの型から別の型への割り当てを行う XmlTypeMapping。

解説

このコンストラクタは、オブジェクトを SOAP メッセージにシリアル化するときに XmlSerializer を作成するために使用します。生成される SOAP メッセージを制御するには、System.Xml.Serialization 名前空間内にある (名前が "Soap" で始まる) 特別な属性を使用します。

使用例

Group というクラスをシリアル化する例を次に示します。GroupName フィールド、IgnoreThis フィールド、および GroupType 列挙体のメンバのシリアル化がオーバーライドされます。CreateOverrideSerializer メソッド内では、SoapAttributeOverrides オブジェクトが作成され、オーバーライド対象のメンバまたは列挙体ごとに、適切なプロパティが設定された SoapAttributes オブジェクトが作成され、それぞれが SoapAttributeOverrides オブジェクトに追加されています。XmlMapping オブジェクトが SoapAttributeOverrides オブジェクトを使用して作成され、その XmlMapping を使用して、既定のシリアル化をオーバーライドする XmlSerializer が作成されます。

Visual Basic

Imports System
Imports System.IO
Imports System.Text
Imports System.Xml
Imports System.Xml.Serialization
Imports System.Xml.Schema

Public Class Group
   <SoapAttribute (Namespace:= "http:'www.cpandl.com")>
 _
   Public GroupName As String
 
   
   <SoapAttribute(DataType:= "base64Binary")>
 _
   Public GroupNumber() As Byte

   <SoapAttribute(DataType:= "date", _
   AttributeName:= "CreationDate")> _
   Public Today As DateTime 
   <SoapElement(DataType:= "nonNegativeInteger",
 _
   ElementName:= "PosInt")> _
   Public PostitiveInt As String
 
   ' This is ignored when serialized unless it's overridden.
   <SoapIgnore> _ 
   Public IgnoreThis As Boolean
 
   
   Public Grouptype As GroupType 

   Public MyVehicle As Vehicle 

   '  The SoapInclude allows the method to return a Car.
   <SoapInclude(GetType(Car))> _
   Public Function myCar(licNumber As
 String ) As Vehicle 
      Dim v As Vehicle 
      if licNumber = "" Then
         v = New Car()
         v.licenseNumber = "!!!!!!"
      else  
          v = New Car()
          v.licenseNumber = licNumber
      End If
      
      return v
   End Function
End Class
  
' SoapInclude allows Vehicle to accept Car type.
<SoapInclude(GetType(Car))> _
Public MustInherit  class
 Vehicle
   Public licenseNumber As String
 
   Public makeDate As DateTime 
End Class

Public Class Car
   Inherits Vehicle

End Class

Public enum GroupType
   ' These enums can be overridden.
   <SoapEnum("Small")> _
   A
   <SoapEnum("Large")> _ 
   B
End Enum
 
Public Class Run

   Shared Sub Main()
      Dim test As Run = New
 Run()
      test.SerializeOriginal("SoapOriginal.xml")
      test.SerializeOverride("SoapOverrides.xml")
      test.DeserializeOriginal("SoapOriginal.xml")
      test.DeserializeOverride("SoapOverrides.xml")
   End SUb
   
   Public Sub SerializeOriginal(filename As
 String)

      ' Create an instance of the XmlSerializer class.
      Dim myMapping As XmlTypeMapping = _
      (New SoapReflectionImporter().ImportTypeMapping _
      (GetType(Group)))
      Dim mySerializer As XmlSerializer = 
 _
      New XmlSerializer(myMapping)
      
      Dim myGroup As Group =MakeGroup()
      ' Writing the file requires a TextWriter.
      Dim writer As XmlTextWriter  = _
      New XmlTextWriter(filename, Encoding.UTF8)
      writer.Formatting = Formatting.Indented
      writer.WriteStartElement("wrapper")
      ' Serialize the class, and close the TextWriter.
      mySerializer.Serialize(writer, myGroup)
      writer.WriteEndElement()
      writer.Close()
   End Sub

   Public Sub SerializeOverride(filename As
 String)
      ' Create an instance of the XmlSerializer class
      ' that overrides the serialization.
      Dim overRideSerializer As XmlSerializer
 = _
      CreateOverrideSerializer()
      Dim myGroup As Group =MakeGroup()
      ' Writing the file requires a TextWriter.
      Dim writer As XmlTextWriter  = _
      New XmlTextWriter(filename, Encoding.UTF8)
      writer.Formatting = Formatting.Indented
      writer.WriteStartElement("wrapper")
      ' Serialize the class, and close the TextWriter.
      overRideSerializer.Serialize(writer, myGroup)
      writer.WriteEndElement()
      writer.Close()
    End Sub

   private Function MakeGroup() As
 Group 
      ' Create an instance of the class that will be serialized.
      Dim myGroup As Group  = New
 Group()

      ' Set the object properties.
      myGroup.GroupName = ".NET"

      Dim hexByte()As Byte = new
 Byte(1){Convert.ToByte(100), _
      Convert.ToByte(50)}
      myGroup.GroupNumber = hexByte

      Dim myDate As DateTime  = new
 DateTime(2002,5,2)
      myGroup.Today = myDate

      myGroup.PostitiveInt = "10000"
    myGroup.IgnoreThis = true
    myGroup.Grouptype = GroupType.B
    Dim thisCar As Car 
    thisCar =CType(myGroup.myCar("1234566"), Car)
    myGroup.myVehicle=thisCar
      return myGroup
   End Function       

   Public Sub DeserializeOriginal(filename
 As String)
      ' Create an instance of the XmlSerializer class.
      Dim myMapping As XmlTypeMapping = _
      (New SoapReflectionImporter().ImportTypeMapping _
      (GetType(Group)))
      Dim mySerializer As XmlSerializer = 
 _
      New XmlSerializer(myMapping)

      ' Reading the file requires an  XmlTextReader.
      Dim reader As XmlTextReader = _
      New XmlTextReader(filename)
      reader.ReadStartElement("wrapper")

      ' Deserialize and cast the object.
      Dim myGroup As Group  = _
      CType(mySerializer.Deserialize(reader), Group)
      reader.ReadEndElement()
      reader.Close()
   End Sub

   Public Sub DeserializeOverride(filename
 As String)
      ' Create an instance of the XmlSerializer class.
      Dim overRideSerializer As XmlSerializer
  = _
      CreateOverrideSerializer()

      ' Reading the file requires an  XmlTextReader.
      Dim reader As XmlTextReader = _
      New XmlTextReader(filename)
      reader.ReadStartElement("wrapper")

      ' Deserialize and cast the object.
      Dim myGroup As Group = _
      CType(overRideSerializer.Deserialize(reader), Group)
      reader.ReadEndElement()
      reader.Close()
      ReadGroup(myGroup)
   End Sub

   private Sub ReadGroup(myGroup As
 Group)
      Console.WriteLine(myGroup.GroupName)
      Console.WriteLine(myGroup.GroupNumber(0))
      Console.WriteLine(myGroup.GroupNumber(1))
      Console.WriteLine(myGroup.Today)
      Console.WriteLine(myGroup.PostitiveInt)
      Console.WriteLine(myGroup.IgnoreThis)
      Console.WriteLine()
   End Sub
   
   Private Function CreateOverrideSerializer()
 As XmlSerializer
      Dim soapOver As SoapAttributeOverrides
 = New SoapAttributeOverrides()
      Dim soapAtts As SoapAttributes = New
 SoapAttributes()

      Dim mySoapElement As SoapElementAttribute
 = New SoapElementAttribute()
      mySoapElement.ElementName = "xxxx"
      soapAtts.SoapElement = mySoapElement
      soapOver.Add(GetType(Group), "PostitiveInt",
 soapAtts)

      ' Override the IgnoreThis property.
      Dim myIgnore As SoapIgnoreAttribute 
 = new SoapIgnoreAttribute()
      soapAtts = New SoapAttributes()
      soapAtts.SoapIgnore = false
      soapOver.Add(GetType(Group), "IgnoreThis",
 soapAtts)

      ' Override the GroupType enumeration.
      soapAtts = New SoapAttributes()
      Dim xSoapEnum As SoapEnumAttribute =
 new SoapEnumAttribute()
      xSoapEnum.Name = "Over1000"
      soapAtts.SoapEnum = xSoapEnum
      ' Add the SoapAttributes to the SoapOverrides object.
      soapOver.Add(GetType(GroupType), "A",
 soapAtts)

      ' Create second enumeration and add it.
      soapAtts = New SoapAttributes()
      xSoapEnum = New SoapEnumAttribute()
      xSoapEnum.Name = "ZeroTo1000"
      soapAtts.SoapEnum = xSoapEnum
      soapOver.Add(GetType(GroupType), "B",
 soapAtts)

      ' Override the Group type.
      soapAtts = New SoapAttributes()
      Dim soapType As SoapTypeAttribute = New
 SoapTypeAttribute()
      soapType.TypeName = "Team"
      soapAtts.SoapType = soapType
      soapOver.Add(GetType(Group),soapAtts)
    
      Dim myMapping As XmlTypeMapping = (New
 SoapReflectionImporter( _
      soapOver)).ImportTypeMapping(GetType(Group))
    
       Dim ser As XmlSerializer = new
 XmlSerializer(myMapping)
      return ser
   End Function
End Class

using System;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.Schema;

public class Group
{
   [SoapAttribute (Namespace = "http://www.cpandl.com")]
   public string GroupName;
   
   [SoapAttribute(DataType = "base64Binary")]
   public Byte [] GroupNumber;

   [SoapAttribute(DataType = "date", AttributeName = "CreationDate")]
   public DateTime Today;
   [SoapElement(DataType = "nonNegativeInteger", ElementName = "PosInt")]
   public string PostitiveInt;
   // This is ignored when serialized unless it's overridden.
   [SoapIgnore] 
   public bool IgnoreThis;
   
   public GroupType Grouptype;

   public Vehicle MyVehicle;

   // The SoapInclude allows the method to return a Car.
   [SoapInclude(typeof(Car))]
   public Vehicle myCar(string licNumber)
   {
      Vehicle v;
      if(licNumber == "")
         {
            v = new Car();
           v.licenseNumber = "!!!!!!";
        }
      else
        {
          v = new Car();
          v.licenseNumber = licNumber;
        }
      return v;
   }
}
  
// SoapInclude allows Vehicle to accept Car type.
[SoapInclude(typeof(Car))]
public abstract class Vehicle
{
   public string licenseNumber;
   public DateTime makeDate;
}

public class Car: Vehicle
{
}

public enum GroupType
{
   // These enums can be overridden.
   [SoapEnum("Small")]
   A,
   [SoapEnum("Large")]
   B
}
 
public class Run
{
   public static void Main()
   {
      Run test = new Run();
      test.SerializeOriginal("SoapOriginal.xml");
      test.SerializeOverride("SoapOverrides.xml");
      test.DeserializeOriginal("SoapOriginal.xml");
      test.DeserializeOverride("SoapOverrides.xml");
   
   }
   public void SerializeOriginal(string
 filename)
   {
      // Create an instance of the XmlSerializer class.
      XmlTypeMapping myMapping = 
      (new SoapReflectionImporter().ImportTypeMapping(
      typeof(Group)));
      XmlSerializer mySerializer =  
      new XmlSerializer(myMapping);
      Group myGroup=MakeGroup();
      // Writing the file requires a TextWriter.
      XmlTextWriter writer = 
      new XmlTextWriter(filename, Encoding.UTF8);
      writer.Formatting = Formatting.Indented;
      writer.WriteStartElement("wrapper");
      // Serialize the class, and close the TextWriter.
      mySerializer.Serialize(writer, myGroup);
      writer.WriteEndElement();
      writer.Close();
   }

   public void SerializeOverride(string
 filename)
   {
      // Create an instance of the XmlSerializer class
      // that overrides the serialization.
      XmlSerializer overRideSerializer = CreateOverrideSerializer();
      Group myGroup=MakeGroup();
      // Writing the file requires a TextWriter.
      XmlTextWriter writer = 
      new XmlTextWriter(filename, Encoding.UTF8);
      writer.Formatting = Formatting.Indented;
      writer.WriteStartElement("wrapper");
      // Serialize the class, and close the TextWriter.
      overRideSerializer.Serialize(writer, myGroup);
      writer.WriteEndElement();
      writer.Close();

   }

   private Group MakeGroup(){
      // Create an instance of the class that will be serialized.
      Group myGroup = new Group();

      // Set the object properties.
      myGroup.GroupName = ".NET";

      Byte [] hexByte = new Byte[2]{Convert.ToByte(100),
      Convert.ToByte(50)};
      myGroup.GroupNumber = hexByte;

      DateTime myDate = new DateTime(2002,5,2);
      myGroup.Today = myDate;
      myGroup.PostitiveInt= "10000";
      myGroup.IgnoreThis=true;
      myGroup.Grouptype= GroupType.B;
      Car thisCar =(Car)  myGroup.myCar("1234566");
      myGroup.MyVehicle=thisCar;
      return myGroup;
   }       

   public void DeserializeOriginal(string
 filename)
   {
      // Create an instance of the XmlSerializer class.
      XmlTypeMapping myMapping = 
      (new SoapReflectionImporter().ImportTypeMapping(
      typeof(Group)));
      XmlSerializer mySerializer =  
      new XmlSerializer(myMapping);


      // Reading the file requires an  XmlTextReader.
      XmlTextReader reader= 
      new XmlTextReader(filename);
      reader.ReadStartElement("wrapper");

      // Deserialize and cast the object.
      Group myGroup; 
      myGroup = (Group) mySerializer.Deserialize(reader);
      reader.ReadEndElement();
      reader.Close();

   }

   public void DeserializeOverride(string
 filename)
   {
      // Create an instance of the XmlSerializer class.
      XmlSerializer overRideSerializer = CreateOverrideSerializer();

      // Reading the file requires an  XmlTextReader.
      XmlTextReader reader= 
      new XmlTextReader(filename);
      reader.ReadStartElement("wrapper");

      // Deserialize and cast the object.
      Group myGroup; 
      myGroup = (Group) overRideSerializer.Deserialize(reader);
      reader.ReadEndElement();
      reader.Close();
      ReadGroup(myGroup);
   }

   private void ReadGroup(Group myGroup){
      Console.WriteLine(myGroup.GroupName);
      Console.WriteLine(myGroup.GroupNumber[0]);
      Console.WriteLine(myGroup.GroupNumber[1]);
      Console.WriteLine(myGroup.Today);
      Console.WriteLine(myGroup.PostitiveInt);
      Console.WriteLine(myGroup.IgnoreThis);
      Console.WriteLine();
   }
   private XmlSerializer CreateOverrideSerializer()
   {
      SoapAttributeOverrides mySoapAttributeOverrides = 
      new SoapAttributeOverrides();
      SoapAttributes soapAtts = new SoapAttributes();

      SoapElementAttribute mySoapElement = new SoapElementAttribute();
      mySoapElement.ElementName = "xxxx";
      soapAtts.SoapElement = mySoapElement;
      mySoapAttributeOverrides.Add(typeof(Group), "PostitiveInt", 
      soapAtts);

      // Override the IgnoreThis property.
      SoapIgnoreAttribute myIgnore = new SoapIgnoreAttribute();
      soapAtts = new SoapAttributes();
      soapAtts.SoapIgnore = false;      
      mySoapAttributeOverrides.Add(typeof(Group), "IgnoreThis", 
      soapAtts);

      // Override the GroupType enumeration.    
      soapAtts = new SoapAttributes();
      SoapEnumAttribute xSoapEnum = new SoapEnumAttribute();
      xSoapEnum.Name = "Over1000";
      soapAtts.SoapEnum = xSoapEnum;

      // Add the SoapAttributes to the 
      // mySoapAttributeOverridesrides object.
      mySoapAttributeOverrides.Add(typeof(GroupType), "A", 
      soapAtts);

      // Create second enumeration and add it.
      soapAtts = new SoapAttributes();
      xSoapEnum = new SoapEnumAttribute();
      xSoapEnum.Name = "ZeroTo1000";
      soapAtts.SoapEnum = xSoapEnum;
      mySoapAttributeOverrides.Add(typeof(GroupType), "B", 
      soapAtts);

      // Override the Group type.
      soapAtts = new SoapAttributes();
      SoapTypeAttribute soapType = new SoapTypeAttribute();
      soapType.TypeName = "Team";
      soapAtts.SoapType = soapType;
      mySoapAttributeOverrides.Add(typeof(Group),soapAtts);

      // Create an XmlTypeMapping that is used to create an instance
 
      // of the XmlSerializer. Then return the XmlSerializer object.
      XmlTypeMapping myMapping = (new SoapReflectionImporter(
      mySoapAttributeOverrides)).ImportTypeMapping(typeof(Group));
    
      XmlSerializer ser = new XmlSerializer(myMapping);
      return ser;
   }
}

import System.*;
import System.IO.*;
import System.Text.*;
import System.Xml.*;
import System.Xml.Serialization.*;
import System.Xml.Schema.*;

public class Group
{
    /** @attribute SoapAttribute(Namespace = "http://www.cpandl.com")
     */
    public String groupName;

    /** @attribute SoapAttribute(DataType = "base64Binary")
     */
    public System.Byte groupNumber[];

    /** @attribute SoapAttribute(DataType = "date", 
        AttributeName = "CreationDate")
     */
    public DateTime today;

    /** @attribute SoapElement(DataType = "nonNegativeInteger", 
        ElementName = "PosInt")
     */
    public String postitiveInt;

    // This is ignored when serialized unless it's overridden.
    /** @attribute SoapIgnore()
     */
    public boolean ignoreThis;
    public GroupType groupType;
    public Vehicle myVehicle;

    // The SoapInclude allows the method to return a Car.
    /** @attribute SoapInclude(Car.class)
     */
    public Vehicle MyCar(String licNumber)
    {
        Vehicle v;
        if (licNumber.Equals("")) {
            v = new Car();
            v.licenseNumber = "!!!!!!";
        }
        else {
            v = new Car();
            v.licenseNumber = licNumber;
        }
        return v;
    } //MyCar
} //Group

// SoapInclude allows Vehicle to accept Car type.
/** @attribute SoapInclude(Car.class)
 */
abstract public class Vehicle
{
    public String licenseNumber;
    public DateTime makeDate;
} //Vehicle

public class Car extends Vehicle
{
} //Car

public class GroupType
{
    public int member;

    public GroupType()
    {
        member = 0;
    } //GroupType

    public GroupType(int n)
    {
        member = n;
    } //GroupType

    /** @attribute SoapEnum("Small")
     */
    public static int a
 = 0;

    /** @attribute SoapEnum("Large")
     */
    public static int b
 = 1;
} //GroupType

public class Run
{
    public static void main(String[]
 args)
    {
        Run test = new Run();
        test.SerializeOriginal("SoapOriginal.xml");
        test.SerializeOverride("SoapOverrides.xml");
        test.DeserializeOriginal("SoapOriginal.xml");
        test.DeserializeOverride("SoapOverrides.xml");
    } //main

    public void SerializeOriginal(String fileName)
    {
        // Create an instance of the XmlSerializer class.
        XmlTypeMapping myMapping = (new SoapReflectionImporter()).
            ImportTypeMapping(Group.class.ToType());
        XmlSerializer mySerializer = new XmlSerializer(myMapping);
        Group myGroup = MakeGroup();
        // Writing the file requires a TextWriter.
        XmlTextWriter writer = new XmlTextWriter(fileName, 
            Encoding.get_UTF8());
        writer.set_Formatting(Formatting.Indented);
        writer.WriteStartElement("wrapper");
        // Serialize the class, and close the TextWriter.
        mySerializer.Serialize(writer, myGroup);
        writer.WriteEndElement();
        writer.Close();
    } //SerializeOriginal

    public void SerializeOverride(String fileName)
    {
        // Create an instance of the XmlSerializer class
        // that overrides the serialization.
        XmlSerializer overRideSerializer = CreateOverrideSerializer();
        Group myGroup = MakeGroup();
        // Writing the file requires a TextWriter.
        XmlTextWriter writer = new XmlTextWriter(fileName, 
            Encoding.get_UTF8());
        writer.set_Formatting(Formatting.Indented);
        writer.WriteStartElement("wrapper");
        // Serialize the class, and close the TextWriter.
        overRideSerializer.Serialize(writer, myGroup);
        writer.WriteEndElement();
        writer.Close();
    } //SerializeOverride

    private Group MakeGroup()
    {
        // Create an instance of the class that will be serialized.
        Group myGroup = new Group();
        // Set the object properties.
        myGroup.groupName = ".NET";

        System.Byte hexByte[] = new System.Byte[] { (System.Byte)100,
 
            (System.Byte)50 };
        myGroup.groupNumber = hexByte;

        DateTime myDate = new DateTime(2002, 5, 2);
        myGroup.today = myDate;
        myGroup.postitiveInt = "10000";
        myGroup.ignoreThis = true;
        myGroup.groupType = new GroupType(GroupType.b);
        Car thisCar = (Car)myGroup.MyCar("1234566");
        myGroup.myVehicle = thisCar;
        return myGroup;
    } //MakeGroup

    public void DeserializeOriginal(String
 fileName)
    {
        // Create an instance of the XmlSerializer class.
        XmlTypeMapping myMapping = (new SoapReflectionImporter()).
            ImportTypeMapping(Group.class.ToType());
        XmlSerializer mySerializer = new XmlSerializer(myMapping);
        // Reading the file requires an  XmlTextReader.
        XmlTextReader reader = new XmlTextReader(fileName);
        reader.ReadStartElement("wrapper");
        // Deserialize and cast the object.
        Group myGroup;
        myGroup = (Group)mySerializer.Deserialize(reader);
        reader.ReadEndElement();
        reader.Close();
    } //DeserializeOriginal

    public void DeserializeOverride(String
 fileName)
    {
        // Create an instance of the XmlSerializer class.
        XmlSerializer overRideSerializer = CreateOverrideSerializer();
        // Reading the file requires an  XmlTextReader.
        XmlTextReader reader = new XmlTextReader(fileName);
        reader.ReadStartElement("wrapper");
        // Deserialize and cast the object.
        Group myGroup;
        myGroup = (Group)overRideSerializer.Deserialize(reader);
        reader.ReadEndElement();
        reader.Close();
        ReadGroup(myGroup);
    } //DeserializeOverride

    private void ReadGroup(Group myGroup)
    {
        Console.WriteLine(myGroup.groupName);
        Console.WriteLine(myGroup.groupNumber.get_Item(0));
        Console.WriteLine(myGroup.groupNumber.get_Item(1));
        Console.WriteLine(myGroup.today);
        Console.WriteLine(myGroup.postitiveInt);
        Console.WriteLine(myGroup.ignoreThis);
        Console.WriteLine();
    } //ReadGroup

    private XmlSerializer CreateOverrideSerializer()
    {
        SoapAttributeOverrides mySoapAttributeOverrides 
            = new SoapAttributeOverrides();
        SoapAttributes soapAtts = new SoapAttributes();

        SoapElementAttribute mySoapElement = new SoapElementAttribute();
        mySoapElement.set_ElementName("xxxx");
        soapAtts.set_SoapElement(mySoapElement);
        mySoapAttributeOverrides.Add(Group.class.ToType(), "postitiveInt",
 
            soapAtts);
        // Override the ignoreThis property.
        SoapIgnoreAttribute myIgnore = new SoapIgnoreAttribute();
        soapAtts = new SoapAttributes();
        soapAtts.set_SoapIgnore(false);
        mySoapAttributeOverrides.Add(Group.class.ToType(), "ignoreThis",
 
            soapAtts);
        // Override the GroupType enumeration.    
        soapAtts = new SoapAttributes();
        SoapEnumAttribute xSoapEnum = new SoapEnumAttribute();
        xSoapEnum.set_Name("Over1000");
        soapAtts.set_SoapEnum(xSoapEnum);
        // Add the SoapAttributes to the 
        // mySoapAttributeOverridesrides object.
        mySoapAttributeOverrides.Add(GroupType.class.ToType(),
 "a", soapAtts);
        // Create second enumeration and add it.
        soapAtts = new SoapAttributes();
        xSoapEnum = new SoapEnumAttribute();
        xSoapEnum.set_Name("ZeroTo1000");
        soapAtts.set_SoapEnum(xSoapEnum);
        mySoapAttributeOverrides.Add(GroupType.class.ToType(),
 "b", soapAtts);
        // Override the Group type.
        soapAtts = new SoapAttributes();
        SoapTypeAttribute soapType = new SoapTypeAttribute();
        soapType.set_TypeName("Team");
        soapAtts.set_SoapType(soapType);
        mySoapAttributeOverrides.Add(Group.class.ToType(), soapAtts);
        // Create an XmlTypeMapping that is used to create an instance
 
        // of the XmlSerializer. Then return the XmlSerializer object.
        XmlTypeMapping myMapping = new SoapReflectionImporter(
            mySoapAttributeOverrides).ImportTypeMapping(Group.class.ToType());

        XmlSerializer ser = new XmlSerializer(myMapping);
        return ser;
    } //CreateOverrideSerializer
} //Run

プラットフォーム

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0

参照

関連項目
XmlSerializer クラス
XmlSerializer メンバ
System.Xml.Serialization 名前空間
XmlAttributes クラス
その他の技術情報
XML シリアル化の概要
方法 : XML ストリームの代替要素名を指定する
属性を使用した XML シリアル化の制御
XML シリアル化の例
XML スキーマ定義ツール (Xsd.exe)

XmlSerializer コンストラクタ (Type, XmlAttributeOverrides)

指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。シリアル化される各オブジェクトはそれ自体がクラスのインスタンスを含むことができ、それをこのオーバーロードによって他のクラスでオーバーライドできます。

名前空間: System.Xml.Serialization
アセンブリ: System.Xml (system.xml.dll 内)
構文

Visual Basic (宣言)

Public Sub New ( _
    type As Type, _
    overrides As XmlAttributeOverrides _
)

Visual Basic (使用法)

Dim type As Type
Dim overrides As XmlAttributeOverrides

Dim instance As New XmlSerializer(type,
 overrides)

public XmlSerializer (
    Type type,
    XmlAttributeOverrides overrides
)

C++

public:
XmlSerializer (
    Type^ type, 
    XmlAttributeOverrides^ overrides
)

public XmlSerializer (
    Type type, 
    XmlAttributeOverrides overrides
)

JScript

public function XmlSerializer (
    type : Type, 
    overrides : XmlAttributeOverrides
)

パラメータ

type: シリアル化するオブジェクトの型。

overrides: XmlAttributeOverrides。

解説

フィールドとプロパティを XML にエンコードする方法を制御するには、overrides パラメータを使用します。これらの設定値により、オブジェクトに既に存在する属性がオーバーライドされます。この機能は、ソースコードを変更できないときや、同一のクラスに複数のエンコーディングが必要なときに役立ちます。

使用例

DLL に定義されているクラスのインスタンスをシリアル化するため、DLL 内のパブリックメンバをオーバーライドする例を次に示します。

Visual Basic

' Beginning of HighSchool.dll
Imports System
Imports System.IO
Imports System.Xml
Imports System.Xml.Serialization
Imports Microsoft.VisualBasic
Imports HighSchool

Namespace HighSchool
    
    Public Class Student
        Public Name As String
        Public ID As Integer
    End Class 'Student
    
    
    Public Class MyClass1
        Public Students() As Student
    End Class 'MyClass1
End Namespace 'HighSchool

Namespace College
    Public Class Graduate
        Inherits HighSchool.Student
        
        Public Sub New()
        End Sub 'New ' Add a new
 field named University.
        Public University As String
    End Class 'Graduate
    
    
    
    Public Class Run
        
        Public Shared Sub
 Main()
            Dim test As New
 Run()
            test.WriteOverriddenAttributes("College.xml")
            test.ReadOverriddenAttributes("College.xml")
        End Sub 'Main
        
        
        Private Sub WriteOverriddenAttributes(filename
 As String)
            ' Writing the file requires a TextWriter.
            Dim myStreamWriter As New
 StreamWriter(filename)
            ' Create an XMLAttributeOverrides class.
            Dim attrOverrides As New
 XmlAttributeOverrides()
            ' Create the XmlAttributes class.
            Dim attrs As New
 XmlAttributes()
            
            ' Override the Student class. "Alumni" is the
 name
            ' of the overriding element in the XML output. 
            Dim attr As New
 XmlElementAttribute("Alumni", GetType(Graduate))
            
            ' Add the XmlElementAttribute to the collection of
            ' elements in the XmlAttributes object. 
            attrs.XmlElements.Add(attr)
            
            ' Add the XmlAttributes to the XmlAttributeOverrides. 
            ' "Students" is the name being overridden. 
            attrOverrides.Add(GetType(HighSchool.MyClass1), "Students",
 attrs)
            
            ' Create the XmlSerializer. 
            Dim mySerializer As New
 XmlSerializer(GetType(HighSchool.MyClass1), attrOverrides)
            
            Dim oMyClass As New
 MyClass1()
            
            Dim g1 As New
 Graduate()
            g1.Name = "Jackie"
            g1.ID = 1
            g1.University = "Alma Mater"
            
            Dim g2 As New
 Graduate()
            g2.Name = "Megan"
            g2.ID = 2
            g2.University = "CM"
            
            Dim myArray As Student() =  {g1,
 g2}
            oMyClass.Students = myArray
            
            mySerializer.Serialize(myStreamWriter, oMyClass)
            myStreamWriter.Close()
        End Sub 'WriteOverriddenAttributes
        
        
        Private Sub ReadOverriddenAttributes(filename
 As String)
            ' The majority of the code here is the same as that in the
            ' WriteOverriddenAttributes method. Because the XML being
 read
            ' doesn't conform to the schema defined by the DLL, the
            ' XMLAttributesOverrides must be used to create an
            ' XmlSerializer instance to read the XML document.
            
            Dim attrOverrides As New
 XmlAttributeOverrides()
            Dim attrs As New
 XmlAttributes()
            Dim attr As New
 XmlElementAttribute("Alumni", GetType(Graduate))
            attrs.XmlElements.Add(attr)
            attrOverrides.Add(GetType(HighSchool.MyClass1), "Students",
 attrs)
            
            Dim readSerializer As New
 XmlSerializer(GetType(HighSchool.MyClass1), attrOverrides)
            
            ' To read the file, a FileStream object is required. 
            Dim fs As New
 FileStream(filename, FileMode.Open)
            
            Dim oMyClass As MyClass1
            
            oMyClass = CType(readSerializer.Deserialize(fs), MyClass1)
            
            ' Here is the difference between reading and writing an
            ' XML document: You must declare an object of the derived
            ' type (Graduate) and cast the Student instance to it.
            Dim g As Graduate
            
            Dim grad As Graduate
            For Each grad In
  oMyClass.Students
                g = CType(grad, Graduate)
                Console.Write((g.Name & ControlChars.Tab))
                Console.Write((g.ID.ToString & ControlChars.Tab))
                Console.Write((g.University & ControlChars.Cr))
            Next grad
        End Sub 'ReadOverriddenAttributes
    End Class 'Run
End Namespace 'College

// Beginning of HighSchool.dll
namespace HighSchool
{
   public class Student
   {
      public string Name;
      public int ID;
   }
    
   public class MyClass
   {
      public Student[] Students;
   }
}

namespace College
   {
   using System;
   using System.IO;
   using System.Xml;
   using System.Xml.Serialization; 
   using HighSchool;

    public class Graduate:HighSchool.Student
    {
       public Graduate(){}
       // Add a new field named University.
       public string University;
    }
 
    
   public class Run
   {
      public static void
 Main()
      {
         Run test = new Run();
         test.WriteOverriddenAttributes("College.xml");
         test.ReadOverriddenAttributes("College.xml");
      }
 
      private void WriteOverriddenAttributes(string
 filename)
      {
         // Writing the file requires a TextWriter.
         TextWriter myStreamWriter = new StreamWriter(filename);
         // Create an XMLAttributeOverrides class.
         XmlAttributeOverrides attrOverrides = 
         new XmlAttributeOverrides();
         // Create the XmlAttributes class.
         XmlAttributes attrs = new XmlAttributes();

         /* Override the Student class. "Alumni" is
 the name
         of the overriding element in the XML output. */
         XmlElementAttribute attr = 
         new XmlElementAttribute("Alumni", typeof(Graduate));

         /* Add the XmlElementAttribute to the collection of
         elements in the XmlAttributes object. */
         attrs.XmlElements.Add(attr);

         /* Add the XmlAttributes to the XmlAttributeOverrides. 
         "Students" is the name being overridden. */
         attrOverrides.Add(typeof(HighSchool.MyClass), 
         "Students", attrs);
          
         // Create the XmlSerializer. 
         XmlSerializer mySerializer = new XmlSerializer
         (typeof(HighSchool.MyClass), attrOverrides);
 
         MyClass myClass = new MyClass();

         Graduate g1 = new Graduate();
         g1.Name = "Jackie";
         g1.ID = 1;
         g1.University = "Alma Mater";

         Graduate g2 = new Graduate();
         g2.Name = "Megan";
         g2.ID = 2;
         g2.University = "CM";

         Student[] myArray = {g1,g2};
         myClass.Students = myArray;
 
         mySerializer.Serialize(myStreamWriter, myClass);
         myStreamWriter.Close();
      }

      private void ReadOverriddenAttributes(string
 filename)
      {
         /* The majority of the code here is the same as that in
 the
         WriteOverriddenAttributes method. Because the XML being read
         doesn't conform to the schema defined by the DLL, the
         XMLAttributesOverrides must be used to create an 
         XmlSerializer instance to read the XML document.*/
          
         XmlAttributeOverrides attrOverrides = new 
         XmlAttributeOverrides();
         XmlAttributes attrs = new XmlAttributes();
         XmlElementAttribute attr = 
         new XmlElementAttribute("Alumni", typeof(Graduate));
         attrs.XmlElements.Add(attr);
         attrOverrides.Add(typeof(HighSchool.MyClass), 
         "Students", attrs);

         XmlSerializer readSerializer = new XmlSerializer
         (typeof(HighSchool.MyClass), attrOverrides);

         // To read the file, a FileStream object is required. 
         FileStream fs = new FileStream(filename, FileMode.Open);
          
         MyClass myClass;

         myClass = (MyClass) readSerializer.Deserialize(fs);

         /* Here is the difference between reading and writing an 
         XML document: You must declare an object of the derived 
         type (Graduate) and cast the Student instance to it.*/
         Graduate g;

         foreach(Graduate grad in myClass.Students)
         {
            g = (Graduate) grad;
            Console.Write(g.Name + "\t");
            Console.Write(g.ID + "\t");
            Console.Write(g.University + "\n");
         }
      }
   }
}

C++

// Beginning of HighSchool.dll
#using <System.Xml.dll>
#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
using namespace System::Xml::Serialization;

namespace HighSchool
{
   public ref class Student
   {
   public:
      String^ Name;
      int ID;
   };

   public ref class MyClass
   {
   public:
      array<Student^>^Students;
   };
}

namespace College
{

using namespace HighSchool;
   public ref class Graduate: public
 HighSchool::Student
   {
   public:
      Graduate(){}

      // Add a new field named University.
      String^ University;
   };

   public ref class Run
   {
   public:
      static void main()
      {
         Run^ test = gcnew Run;
         test->WriteOverriddenAttributes( "College.xml" );
         test->ReadOverriddenAttributes( "College.xml" );
      }

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

         // Create an XMLAttributeOverrides class.
         XmlAttributeOverrides^ attrOverrides = gcnew XmlAttributeOverrides;

         // Create the XmlAttributes class.
         XmlAttributes^ attrs = gcnew XmlAttributes;

         /* Override the Student class. "Alumni" is
 the name
               of the overriding element in the XML output. */
         XmlElementAttribute^ attr = gcnew XmlElementAttribute( "Alumni",Graduate::typeid
 );

         /* Add the XmlElementAttribute to the collection of
               elements in the XmlAttributes object. */
         attrs->XmlElements->Add( attr );

         /* Add the XmlAttributes to the XmlAttributeOverrides. 
               "Students" is the name being overridden. */
         attrOverrides->Add( HighSchool::MyClass::typeid, "Students",
 attrs );

         // Create the XmlSerializer. 
         XmlSerializer^ mySerializer = gcnew XmlSerializer( HighSchool::MyClass::typeid,attrOverrides
 );
         MyClass ^ myClass = gcnew MyClass;
         Graduate^ g1 = gcnew Graduate;
         g1->Name = "Jackie";
         g1->ID = 1;
         g1->University = "Alma Mater";
         Graduate^ g2 = gcnew Graduate;
         g2->Name = "Megan";
         g2->ID = 2;
         g2->University = "CM";
         array<Student^>^myArray = {g1,g2};
         myClass->Students = myArray;
         mySerializer->Serialize( myStreamWriter, myClass );
         myStreamWriter->Close();
      }

      void ReadOverriddenAttributes( String^ filename )
      {
         /* The majority of the code here is the same as that in
 the
               WriteOverriddenAttributes method. Because the XML being read
               doesn't conform to the schema defined by the DLL, the
               XMLAttributesOverrides must be used to create an 
               XmlSerializer instance to read the XML document.*/
         XmlAttributeOverrides^ attrOverrides = gcnew XmlAttributeOverrides;
         XmlAttributes^ attrs = gcnew XmlAttributes;
         XmlElementAttribute^ attr = gcnew XmlElementAttribute( "Alumni",Graduate::typeid
 );
         attrs->XmlElements->Add( attr );
         attrOverrides->Add( HighSchool::MyClass::typeid, "Students",
 attrs );
         XmlSerializer^ readSerializer = gcnew XmlSerializer( HighSchool::MyClass::typeid,attrOverrides
 );
         
         // To read the file, a FileStream object is required. 
         FileStream^ fs = gcnew FileStream( filename,FileMode::Open );
         MyClass ^ myClass;
         myClass = dynamic_cast<MyClass^>(readSerializer->Deserialize( fs
 ));

         /* Here is the difference between reading and writing an 
               XML document: You must declare an object of the derived 
               type (Graduate) and cast the Student instance to it.*/
         Graduate^ g;
         System::Collections::IEnumerator^ myEnum = myClass->Students->GetEnumerator();
         while ( myEnum->MoveNext() )
         {
            Graduate^ grad = safe_cast<Graduate^>(myEnum->Current);
            g = dynamic_cast<Graduate^>(grad);
            Console::Write( "{0}\t", g->Name );
            Console::Write( "{0}\t", g->ID );
            Console::Write( "{0}\n", g->University );
         }
      }
   };
}

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

package College;

import System.*;
import System.IO.*;
import System.Xml.*;
import System.Xml.Serialization.*;
import HighSchool.*;

public class Graduate extends HighSchool.Student
{
    public Graduate()
    {        
    } //Graduate
    // Add a new field named University.
    public String university;
} //Graduate

public class Run
{
    public static void main(String[]
 args)
    {
        Run test = new Run();
        test.WriteOverriddenAttributes("College.xml");
        test.ReadOverriddenAttributes("College.xml");
    } //main

    private void WriteOverriddenAttributes(String
 filename)
    {
        // Writing the file requires a TextWriter.
        TextWriter myStreamWriter = new StreamWriter(filename);

        // Create an XMLAttributeOverrides class.
        XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();

        // Create the XmlAttributes class.
        XmlAttributes attrs = new XmlAttributes();

        /* Override the Student class. "Alumni" is the
 name
           of the overriding element in the XML output. */
        XmlElementAttribute attr =
            new XmlElementAttribute("Alumni", Graduate.class.ToType());

        /* Add the XmlElementAttribute to the collection of
           elements in the XmlAttributes object. */
        attrs.get_XmlElements().Add(attr);

        /* Add the XmlAttributes to the XmlAttributeOverrides. 
           "Students" is the name being overridden. */
        attrOverrides.Add(HighSchool.MyClass.class.ToType(), "students",
 attrs);

        // Create the XmlSerializer. 
        XmlSerializer mySerializer =
            new XmlSerializer(HighSchool.MyClass.class.ToType(),
 attrOverrides);
        MyClass myClass = new MyClass();

        Graduate g1 = new Graduate();
        g1.name = "Jackie";
        g1.iD = 1;
        g1.university = "Alma Mater";

        Graduate g2 = new Graduate();
        g2.name = "Megan";
        g2.iD = 2;
        g2.university = "CM";

        Student myArray[] =  { g1, g2 };
        myClass.students = myArray;

        mySerializer.Serialize(myStreamWriter, myClass);
        myStreamWriter.Close();
    } //WriteOverriddenAttributes

    private void ReadOverriddenAttributes(String
 filename)
    {
        /* The majority of the code here is the same as that in
 the
           WriteOverriddenAttributes method. Because the XML being read
           doesn't conform to the schema defined by the DLL, the
           XMLAttributesOverrides must be used to create an 
           XmlSerializer instance to read the XML document.*/
        XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();
        XmlAttributes attrs = new XmlAttributes();
        XmlElementAttribute attr =
            new XmlElementAttribute("Alumni", Graduate.class.ToType());
        attrs.get_XmlElements().Add(attr);
        attrOverrides.Add(HighSchool.MyClass.class.ToType(), "students",
 attrs);

        XmlSerializer readSerializer =
            new XmlSerializer(HighSchool.MyClass.class.ToType(),
 attrOverrides);

        // To read the file, a FileStream object is required. 
        FileStream fs = new FileStream(filename, FileMode.Open);
        MyClass myClass;
        myClass = (MyClass)readSerializer.Deserialize(fs);

        /* Here is the difference between reading and writing an 
           XML document: You must declare an object of the derived 
           type (Graduate) and cast the Student instance to it.*/
        Graduate g;
        for (int iCtr = 0; iCtr < myClass.students.length;
 iCtr++) {
            Graduate grad = (Graduate)myClass.students[iCtr];
            g = (Graduate)grad;
            Console.Write(g.name + "\t");
            Console.Write(g.iD + "\t");
            Console.Write(g.university + "\n");
        }
    } //ReadOverriddenAttributes
} //Run

package HighSchool;
// Beginning of HighSchool.dll
public class Student
{
    public String name;
    public int iD;
} //Student

public class MyClass
{
    public Student students[];
} //MyClass

プラットフォーム

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0

参照

関連項目
XmlSerializer クラス
XmlSerializer メンバ
System.Xml.Serialization 名前空間
XmlAttributeOverrides クラス
XmlAttributes クラス
その他の技術情報
XML シリアル化の概要
方法 : XML ストリームの代替要素名を指定する
属性を使用した XML シリアル化の制御
XML シリアル化の例
XML スキーマ定義ツール (Xsd.exe)

XmlSerializer コンストラクタ (Type, Type[])

指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。プロパティまたはフィールドが配列を返す場合、extraTypes パラメータには、その配列に挿入できるオブジェクトを指定します。

名前空間: System.Xml.Serialization
アセンブリ: System.Xml (system.xml.dll 内)
構文

Visual Basic (宣言)

Public Sub New ( _
    type As Type, _
    extraTypes As Type() _
)

Visual Basic (使用法)

Dim type As Type
Dim extraTypes As Type()

Dim instance As New XmlSerializer(type,
 extraTypes)

public XmlSerializer (
    Type type,
    Type[] extraTypes
)

C++

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

public XmlSerializer (
    Type type, 
    Type[] extraTypes
)

JScript

public function XmlSerializer (
    type : Type, 
    extraTypes : Type[]
)

パラメータ

type: XmlSerializer がシリアル化できるオブジェクトの型。

extraTypes: シリアル化する追加のオブジェクト型の Type 配列。

解説

既定では、パブリックプロパティまたはパブリックフィールドがオブジェクトまたはオブジェクトの配列を返したときには、それらのオブジェクトの型が自動的にシリアル化されます。ただし、Object 型の配列を返すフィールドまたはプロパティがクラスに含まれている場合は、すべてのオブジェクトが配列に挿入されます。この場合、XmlSerializer に対して、Object 配列に挿入される可能性のあるすべてのオブジェクトの型を通知しておく必要があります。この場合は、extraTypes パラメータを使用して、シリアル化または逆シリアル化する追加のオブジェクト型を指定する必要があります。

extraTypes パラメータを使用して、基本クラスから派生する型を指定することもできます。たとえば、Phone という名前の基本クラスがあり、このクラスから InternationalPhone という名前のクラスが派生するとします。extraTypes パラメータを使用して、この派生型を指定することもできます。

使用例

オブジェクトの配列を返すパブリックフィールドを含むクラスのインスタンスをシリアル化する例を次に示します。XmlSerializer コンストラクタの extraTypes パラメータは、シリアル化して配列に挿入できるオブジェクトの型を指定します。

Visual Basic

Imports System
Imports System.IO
Imports System.Xml
Imports System.Xml.Serialization



' This defines the object that will be serialized.
Public Class Teacher
    Public Name As String
    
    Public Sub New()
    End Sub 'New 
    ' 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)> _
    Public Info() As Object
    Public PhoneInfo As Phone
End Class 'Teacher


' This defines one of the extra types to be included.
Public Class Address
    Public City As String
    
    Public Sub New()
    End Sub 'New
    
    Public Sub New(city
 As String)
        me.City = city
    End Sub 'New
End Class 'Address
 

' Another extra type to include.
Public Class Phone
    Public PhoneNumber As String
    
    Public Sub New()
    End Sub 'New
    
    Public Sub New(phoneNumber
 As String)
        me.PhoneNumber = phoneNumber
    End Sub 'New
End Class 'Phone


' Another type, derived from Phone.
Public Class InternationalPhone
    Inherits Phone
    Public CountryCode As String
    
    
    Public Sub New()
    End Sub 'New
     
    Public Sub New(countryCode
 As String)
        me.CountryCode = countryCode
    End Sub 'New
End Class 'InternationalPhone


Public Class Run
    
    Public Shared Sub Main()
        Dim test As New
 Run()
        test.SerializeObject("Teacher.xml")
        test.DeserializeObject("Teacher.xml")
    End Sub 'Main
    
    
    Private Sub SerializeObject(filename As
 String)
        ' Writing the file requires a TextWriter.
        Dim myStreamWriter As New
 StreamWriter(filename)
        
        ' Create a Type array.
        Dim extraTypes(2) As Type
        extraTypes(0) = GetType(Address)
        extraTypes(1) = GetType(Phone)
        extraTypes(2) = GetType(InternationalPhone)
        
        ' Create the XmlSerializer instance.
        Dim mySerializer As New
 XmlSerializer(GetType(Teacher), extraTypes)
        
        Dim teacher As New
 Teacher()
        teacher.Name = "Mike"
        ' Add extra types to the Teacher object.
        Dim info(1) As Object
        info(0) = New Address("Springville")
        info(1) = New Phone("555-0100")
        
        teacher.Info = info
        
        teacher.PhoneInfo = New InternationalPhone("000")
        
        mySerializer.Serialize(myStreamWriter, teacher)
        myStreamWriter.Close()
    End Sub 'SerializeObject
    
    
    Private Sub DeserializeObject(filename
 As String)
        ' Create a Type array.
        Dim extraTypes(2) As Type
        extraTypes(0) = GetType(Address)
        extraTypes(1) = GetType(Phone)
        extraTypes(2) = GetType(InternationalPhone)
        
        ' Create the XmlSerializer instance.
        Dim mySerializer As New
 XmlSerializer(GetType(Teacher), extraTypes)
        
        ' Reading a file requires a FileStream.
        Dim fs As New FileStream(filename,
 FileMode.Open)
        Dim teacher As Teacher = CType(mySerializer.Deserialize(fs),
 Teacher)
        
        ' Read the extra information.
        Dim a As Address = CType(teacher.Info(0),
 Address)
        Dim p As Phone = CType(teacher.Info(1),
 Phone)
        Dim Ip As InternationalPhone = CType(teacher.PhoneInfo,
 InternationalPhone)
        
        Console.WriteLine(teacher.Name)
        Console.WriteLine(a.City)
        Console.WriteLine(p.PhoneNumber)
        Console.WriteLine(Ip.CountryCode)
    End Sub 'DeserializeObject
End Class 'Run

using System;
using System.IO;
using System.Xml;
using System.Xml.Serialization;

// This defines the object that will be serialized.
public class Teacher
{  
   public string Name;
   public 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)]
   public object[] Info;
   public Phone PhoneInfo;
}
 
// This defines one of the extra types to be included.
public class Address
{  
   public string City;

   public Address(){}
   public Address(string city)
   {
      City = city;
   }

}

// Another extra type to include.
public class Phone
{
   public string PhoneNumber;
   public Phone(){}
   public Phone(string phoneNumber)
   {
      PhoneNumber = phoneNumber;
   }
}

// Another type, derived from Phone
public class InternationalPhone:Phone
{
   public string CountryCode;

   public InternationalPhone(){}

   public InternationalPhone(string countryCode)
   {
      CountryCode = countryCode;
   }
}
    
public class Run
{
   public static void Main()
   {
      Run test = new Run();
      test.SerializeObject("Teacher.xml");
      test.DeserializeObject("Teacher.xml");
   }
 
   private void SerializeObject(string
 filename)
   {
      // Writing the file requires a TextWriter.
      TextWriter myStreamWriter = new StreamWriter(filename);
 
      // Create a Type array.
      Type [] extraTypes= new Type[3];
      extraTypes[0] = typeof(Address);
      extraTypes[1] = typeof(Phone);
      extraTypes[2] = typeof(InternationalPhone);

      // Create the XmlSerializer instance.
      XmlSerializer mySerializer = new XmlSerializer
      (typeof(Teacher),extraTypes);
          
      Teacher teacher = new Teacher();
      teacher.Name = "Mike";
      // Add extra types to the Teacher object
      object [] info = new object[2];
      info[0] = new Address("Springville");
      info[1] = new Phone("555-0100");
         
      teacher.Info = info;

      teacher.PhoneInfo = new InternationalPhone("000");
 

      mySerializer.Serialize(myStreamWriter,teacher);
      myStreamWriter.Close();
   }
 
   private void DeserializeObject(string
 filename)
   {
      // Create a Type array.
      Type [] extraTypes= new Type[3];
      extraTypes[0] = typeof(Address);
      extraTypes[1] = typeof(Phone);
      extraTypes[2] = typeof(InternationalPhone);

      // Create the XmlSerializer instance.
      XmlSerializer mySerializer = new XmlSerializer
      (typeof(Teacher),extraTypes);
      
      // Reading a file requires a FileStream.
      FileStream fs = new FileStream(filename, FileMode.Open);
      Teacher teacher = (Teacher) mySerializer.Deserialize(fs);
         
      // Read the extra information.
      Address a = (Address)teacher.Info[0];
      Phone p = (Phone) teacher.Info[1];
      InternationalPhone Ip = 
      (InternationalPhone) teacher.PhoneInfo;

      Console.WriteLine(teacher.Name);
      Console.WriteLine(a.City);
      Console.WriteLine(p.PhoneNumber);
      Console.WriteLine(Ip.CountryCode);
   }
}

C++

#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();
}

import System.*;
import System.IO.*;
import System.Xml.*;
import System.Xml.Serialization.*;

// This defines the object that will be serialized.
public class Teacher
{
    public String name;

    public Teacher()
    {
    } //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. */
    /** @attribute XmlArray(ElementName = "ExtraInfo", IsNullable = true)
     */
    public Object info[];
    public Phone phoneInfo;
} //Teacher

// This defines one of the extra types to be included.
public class Address
{
    public String city;
    public Address()
    {
    } //Address
    public Address(String tCity)
    {
        city = tCity;
    } //Address
} //Address 

// Another extra type to include.
public class Phone
{
    public String phoneNumber;
    public Phone()
    {
    } //Phone
    public Phone(String tPhoneNumber)
    {
        phoneNumber = tPhoneNumber;
    } //Phone
} //Phone

// Another type, derived from Phone
public class InternationalPhone extends Phone
{
    public String countryCode;
    public InternationalPhone()
    {
    } //InternationalPhone
    public InternationalPhone(String tCountryCode)
    {
        countryCode = tCountryCode;
    } //InternationalPhone
} //InternationalPhone

public class Run
{
    public static void main(String[]
 args)
    {
        Run test = new Run();
        test.SerializeObject("Teacher.xml");
        test.DeserializeObject("Teacher.xml");
    } //main

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

        // Create a Type array.
        Type extraTypes[] = new Type[3];

        extraTypes.set_Item(0, Address.class.ToType());
        extraTypes.set_Item(1, Phone.class.ToType());
        extraTypes.set_Item(2, InternationalPhone.class.ToType());

        // Create the XmlSerializer instance.
        XmlSerializer mySerializer =
            new XmlSerializer(Teacher.class.ToType(),
 extraTypes);
        Teacher teacher = new Teacher();

        teacher.name = "Mike";

        // Add extra types to the Teacher object
        Object info[] = new Object[2];

        info.set_Item(0, new Address("Springville"));
        info.set_Item(1, new Phone("000-0000"));
        teacher.info = info;
        teacher.phoneInfo = new InternationalPhone("000");
        mySerializer.Serialize(myStreamWriter, teacher);
        myStreamWriter.Close();
    } //SerializeObject


    private void DeserializeObject(String filename)
    {
        // Create a Type array.
        Type extraTypes[] = new Type[3];

        extraTypes.set_Item(0, Address.class.ToType());
        extraTypes.set_Item(1, Phone.class.ToType());
        extraTypes.set_Item(2, InternationalPhone.class.ToType());

        // Create the XmlSerializer instance.
        XmlSerializer mySerializer =
            new XmlSerializer(Teacher.class.ToType(),
 extraTypes);

        // Reading a file requires a FileStream.
        FileStream fs = new FileStream(filename, FileMode.Open);
        Teacher teacher = (Teacher)mySerializer.Deserialize(fs);

        // Read the extra information.
        Address a = (Address)teacher.info[0];
        Phone p = (Phone)teacher.info[1];
        InternationalPhone ip = (InternationalPhone)teacher.phoneInfo;

        Console.WriteLine(teacher.name);
        Console.WriteLine(a.city);
        Console.WriteLine(p.phoneNumber);
        Console.WriteLine(ip.countryCode);
    } //DeserializeObject
} //Run

プラットフォーム

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0

参照

XmlSerializer コンストラクタ (Type, XmlRootAttribute)

指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。また、XML ルート要素として使用するクラスを指定します。

名前空間: System.Xml.Serialization
アセンブリ: System.Xml (system.xml.dll 内)
構文

Visual Basic (宣言)

Public Sub New ( _
    type As Type, _
    root As XmlRootAttribute _
)

Visual Basic (使用法)

Dim type As Type
Dim root As XmlRootAttribute

Dim instance As New XmlSerializer(type,
 root)

public XmlSerializer (
    Type type,
    XmlRootAttribute root
)

C++

public:
XmlSerializer (
    Type^ type, 
    XmlRootAttribute^ root
)

public XmlSerializer (
    Type type, 
    XmlRootAttribute root
)

JScript

public function XmlSerializer (
    type : Type, 
    root : XmlRootAttribute
)

パラメータ

type: XmlSerializer がシリアル化できるオブジェクトの型。

root: XML ルート要素を表す XmlRootAttribute。

解説

使用例

名前空間や要素名などの XML ルート要素の各種プロパティを含む XmlRootAttribute を使用する XmlSerializer の構築例を次に示します。

Visual Basic

Private Sub SerializeObject(ByVal
 filename As String)
    ' Create an XmlRootAttribute, and set its properties.
    Dim xRoot As New XmlRootAttribute()
    xRoot.ElementName = "CustomRoot"
    xRoot.Namespace = "http://www.cpandl.com"
    xRoot.IsNullable = True
    
    ' Construct the XmlSerializer with the XmlRootAttribute.
    Dim serializer As New
 XmlSerializer(GetType(OrderedItem), xRoot)
    
    ' Create an instance of the object to serialize.
    Dim i As New OrderedItem()
    ' Insert code to set properties of the ordered item.
    ' Writing the document requires a TextWriter.
    Dim writer As New StreamWriter(filename)
    
    serializer.Serialize(writer, i)
    writer.Close()
End Sub
    
Private Sub DeserializeObject(ByVal
 filename As String)
    ' Create an XmlRootAttribute, and set its properties.
    Dim xRoot As New XmlRootAttribute()
    xRoot.ElementName = "CustomRoot"
    xRoot.Namespace = "http://www.cpandl.com"
    xRoot.IsNullable = True
    
    Dim serializer As New
 XmlSerializer(GetType(OrderedItem), xRoot)
    
    ' A FileStream is needed to read the XML document.
    Dim fs As New FileStream(filename,
 FileMode.Open)
    ' Deserialize the object.
    Dim i As OrderedItem = CType(serializer.Deserialize(fs),
 OrderedItem)
    ' Insert code to use the object's properties and methods.
End Sub

private void SerializeObject(string
 filename) {
    // Create an XmlRootAttribute, and set its properties.
    XmlRootAttribute xRoot = new XmlRootAttribute();
    xRoot.ElementName = "CustomRoot";
    xRoot.Namespace = "http://www.cpandl.com";
    xRoot.IsNullable = true;
     
    // Construct the XmlSerializer with the XmlRootAttribute.
    XmlSerializer serializer = new XmlSerializer
        (typeof(OrderedItem),xRoot);
     
    // Create an instance of the object to serialize.
    OrderedItem i = new OrderedItem();
    // Insert code to set properties of the ordered item.
     
    // Writing the document requires a TextWriter.
    TextWriter writer = new StreamWriter(filename);
     
    serializer.Serialize(writer, i);
    writer.Close();
}

private void DeserializeObject(string
 filename) {
    // Create an XmlRootAttribute, and set its properties.
    XmlRootAttribute xRoot = new XmlRootAttribute();
    xRoot.ElementName = "CustomRoot";
    xRoot.Namespace = "http://www.cpandl.com";
    xRoot.IsNullable = true;
     
    XmlSerializer serializer = new XmlSerializer
        (typeof(OrderedItem),xRoot);
     
    // A FileStream is needed to read the XML document.
    FileStream fs = new FileStream(filename, FileMode.Open);
    // Deserialize the object.
    OrderedItem i = (OrderedItem) serializer.Deserialize(fs);
    // Insert code to use the object's properties and methods.
}

C++

private:
   void SerializeObject( String^ filename )
   {
      // Create an XmlRootAttribute, and set its properties.
      XmlRootAttribute^ xRoot = gcnew XmlRootAttribute;
      xRoot->ElementName = "CustomRoot";
      xRoot->Namespace = "http://www.cpandl.com";
      xRoot->IsNullable = true;

      // Construct the XmlSerializer with the XmlRootAttribute.
      XmlSerializer^ serializer = gcnew XmlSerializer(
         OrderedItem::typeid,xRoot );

      // Create an instance of the object to serialize.
      OrderedItem^ i = gcnew OrderedItem;
      // Insert code to set properties of the ordered item.

      // Writing the document requires a TextWriter.
      TextWriter^ writer = gcnew StreamWriter( filename );
      serializer->Serialize( writer, i );
      writer->Close();
   }

   void DeserializeObject( String^ filename )
   {
      // Create an XmlRootAttribute, and set its properties.
      XmlRootAttribute^ xRoot = gcnew XmlRootAttribute;
      xRoot->ElementName = "CustomRoot";
      xRoot->Namespace = "http://www.cpandl.com";
      xRoot->IsNullable = true;

      XmlSerializer^ serializer = gcnew XmlSerializer(
         OrderedItem::typeid,xRoot );

      // A FileStream is needed to read the XML document.
      FileStream^ fs = gcnew FileStream( filename,FileMode::Open );
      // Deserialize the object.
      OrderedItem^ i = dynamic_cast<OrderedItem^>(serializer->Deserialize(
 fs ));
      // Insert code to use the object's properties and methods.
   }

private void SerializeObject(String filename)
{
    // Create an XmlRootAttribute, and set its properties.
    XmlRootAttribute xRoot = new XmlRootAttribute();
    xRoot.set_ElementName("CustomRoot");
    xRoot.set_Namespace("http://www.cpandl.com");
    xRoot.set_IsNullable(true);

    // Construct the XmlSerializer with the XmlRootAttribute.
    XmlSerializer serializer =
        new XmlSerializer(OrderedItem.class.ToType(),
 xRoot);

    // Create an instance of the object to serialize.
    OrderedItem i = new OrderedItem();

    // Insert code to set properties of the ordered item.
    // Writing the document requires a TextWriter.
    TextWriter writer = new StreamWriter(filename);
    serializer.Serialize(writer, i);
    writer.Close();
} //SerializeObject

private void DeserializeObject(String filename)
{
    // Create an XmlRootAttribute, and set its properties.
    XmlRootAttribute xRoot = new XmlRootAttribute();
    xRoot.set_ElementName("CustomRoot");
    xRoot.set_Namespace("http://www.cpandl.com");
    xRoot.set_IsNullable(true);

    XmlSerializer serializer =
        new XmlSerializer(OrderedItem.class.ToType(),
 xRoot);

    // A FileStream is needed to read the XML document.
    FileStream fs = new FileStream(filename, FileMode.Open);

    // Deserialize the object.
    OrderedItem i = (OrderedItem)serializer.Deserialize(fs);
    // Insert code to use the object's properties and methods.
} //DeserializeObject

プラットフォーム

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0

参照

XmlSerializer コンストラクタ (Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String, String, Evidence)

メモ : このコンストラクタは、.NET Framework version 2.0 で新しく追加されたものです。

このコンストラクタは、.NET Framework インフラストラクチャをサポートします。独自に作成したコードから直接使用するためのものではありません。

指定した型のオブジェクトを XML ドキュメントインスタンスにシリアル化したり、XML ドキュメントインスタンスを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。このオーバーロードでは、シリアル化操作または逆シリアル化操作で見つかる可能性がある他の型、すべての XML 要素の既定の名前空間、XML ルート要素として使用されるクラスとその場所、およびアクセスで要求される資格情報を提供できます。

名前空間: System.Xml.Serialization
アセンブリ: System.Xml (system.xml.dll 内)
構文

Visual Basic (宣言)

Public Sub New ( _
    type As Type, _
    overrides As XmlAttributeOverrides, _
    extraTypes As Type(), _
    root As XmlRootAttribute, _
    defaultNamespace As String, _
    location As String, _
    evidence As Evidence _
)

Visual Basic (使用法)

Dim type As Type
Dim overrides As XmlAttributeOverrides
Dim extraTypes As Type()
Dim root As XmlRootAttribute
Dim defaultNamespace As String
Dim location As String
Dim evidence As Evidence

Dim instance As New XmlSerializer(type,
 overrides, extraTypes, root, defaultNamespace, location, evidence)

public XmlSerializer (
    Type type,
    XmlAttributeOverrides overrides,
    Type[] extraTypes,
    XmlRootAttribute root,
    string defaultNamespace,
    string location,
    Evidence evidence
)

C++

public:
XmlSerializer (
    Type^ type, 
    XmlAttributeOverrides^ overrides, 
    array<Type^>^ extraTypes, 
    XmlRootAttribute^ root, 
    String^ defaultNamespace, 
    String^ location, 
    Evidence^ evidence
)

public XmlSerializer (
    Type type, 
    XmlAttributeOverrides overrides, 
    Type[] extraTypes, 
    XmlRootAttribute root, 
    String defaultNamespace, 
    String location, 
    Evidence evidence
)

JScript

public function XmlSerializer (
    type : Type, 
    overrides : XmlAttributeOverrides, 
    extraTypes : Type[], 
    root : XmlRootAttribute, 
    defaultNamespace : String, 
    location : String, 
    evidence : Evidence
)

パラメータ

type: XmlSerializer がシリアル化できるオブジェクトの型。

overrides: type パラメータで指定されたクラスの動作を拡張またはオーバーライドする XmlAttributeOverrides。

extraTypes: シリアル化する追加のオブジェクト型の Type 配列。

root: XML ルート要素プロパティを定義する XmlRootAttribute。

defaultNamespace: XML ドキュメント内のすべての XML 要素の既定の名前空間。

location: 型の位置。

evidence: 型にアクセスするために必要な資格情報を含む Evidence クラスのインスタンス。

解説

一時ディレクトリへのアクセスに対して、より正確な制御ができるので、コードの挿入や盗用を防ぐことができます。このメソッドを使用するには、場所を指定して、特定のユーザーだけがアクセスできるようにします。管理者は、証拠をアクセス許可と対応させる証拠リストを指定したポリシーを設定できます。

プラットフォーム

バージョン情報

.NET Framework
サポート対象 : 2.0

参照

関連項目
XmlSerializer クラス
XmlSerializer メンバ
System.Xml.Serialization 名前空間

XmlSerializer コンストラクタ (Type, String)

指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。すべての XML 要素の既定の名前空間を指定します。

名前空間: System.Xml.Serialization
アセンブリ: System.Xml (system.xml.dll 内)
構文

Visual Basic (宣言)

Public Sub New ( _
    type As Type, _
    defaultNamespace As String _
)

Visual Basic (使用法)

Dim type As Type
Dim defaultNamespace As String

Dim instance As New XmlSerializer(type,
 defaultNamespace)

public XmlSerializer (
    Type type,
    string defaultNamespace
)

C++

public:
XmlSerializer (
    Type^ type, 
    String^ defaultNamespace
)

public XmlSerializer (
    Type type, 
    String defaultNamespace
)

JScript

public function XmlSerializer (
    type : Type, 
    defaultNamespace : String
)

パラメータ

type: XmlSerializer がシリアル化できるオブジェクトの型。

defaultNamespace: すべての XML 要素で使用する既定の名前空間。

使用例

Visual Basic

Private Sub SerializeObject(ByVal
 filename As String)
    Dim serializer As New
 XmlSerializer(GetType(OrderedItem), _
                                          "http://www.cpandl.com")
    
    ' Create an instance of the class to be serialized.
    Dim i As New OrderedItem()
    
    ' Insert code to set property values.
    ' Writing the document requires a TextWriter.
    Dim writer As New StreamWriter(filename)
    ' Serialize the object, and close the TextWriter.
    serializer.Serialize(writer, i)
    writer.Close()
End Sub


Private Sub DeserializeObject(ByVal
 filename As String)
    Dim serializer As New
 XmlSerializer(GetType(OrderedItem), _
                                          "http://www.cpandl.com")
    ' A FileStream is needed to read the XML document.
    Dim fs As New FileStream(filename,
 FileMode.Open)
    
    ' Declare an object variable of the type to be deserialized.
    Dim i As OrderedItem
    
    ' Deserialize the object.
    i = CType(serializer.Deserialize(fs), OrderedItem)
    ' Insert code to use the properties and methods of the object.
End Sub

private void SerializeObject(string
 filename) {
    XmlSerializer serializer = new XmlSerializer
        (typeof(OrderedItem), "http://www.cpandl.com");
     
    // Create an instance of the class to be serialized.
    OrderedItem i = new OrderedItem();
     
    // Insert code to set property values.
     
    // Writing the document requires a TextWriter.
    TextWriter writer = new StreamWriter(filename);
    // Serialize the object, and close the TextWriter
    serializer.Serialize(writer, i);
    writer.Close();
}
 
private void DeserializeObject(string
 filename) {
    XmlSerializer serializer = new XmlSerializer
        (typeof(OrderedItem), "http://www.cpandl.com");
    // A FileStream is needed to read the XML document.
    FileStream fs = new FileStream(filename, FileMode.Open);
     
    // Declare an object variable of the type to be deserialized.
    OrderedItem i;
     
    // Deserialize the object.
    i = (OrderedItem) serializer.Deserialize(fs);
     
    // Insert code to use the properties and methods of the object.
}

C++

private:
   void SerializeObject( String^ filename )
   {
      XmlSerializer^ serializer = gcnew XmlSerializer(
         OrderedItem::typeid,"http://www.cpandl.com" );

      // Create an instance of the class to be serialized.
      OrderedItem^ i = gcnew OrderedItem;

      // Insert code to set property values.

      // Writing the document requires a TextWriter.
      TextWriter^ writer = gcnew StreamWriter( filename );
      // Serialize the object, and close the TextWriter
      serializer->Serialize( writer, i );
      writer->Close();
   }

   void DeserializeObject( String^ filename )
   {
      XmlSerializer^ serializer = gcnew XmlSerializer(
         OrderedItem::typeid,"http://www.cpandl.com" );
      // A FileStream is needed to read the XML document.
      FileStream^ fs = gcnew FileStream( filename,FileMode::Open );

      // Declare an object variable of the type to be deserialized.
      OrderedItem^ i;

      // Deserialize the object.
      i = dynamic_cast<OrderedItem^>(serializer->Deserialize( fs ));

      // Insert code to use the properties and methods of the object.
   }

private void SerializeObject(String filename)
{
    XmlSerializer serializer =
        new XmlSerializer(OrderedItem.class.ToType()
,
        "http://www.cpandl.com");

    // Create an instance of the class to be serialized.
    OrderedItem i = new OrderedItem();

    // Insert code to set property values.
    // Writing the document requires a TextWriter.
    TextWriter writer = new StreamWriter(filename);

    // Serialize the object, and close the TextWriter
    serializer.Serialize(writer, i);
    writer.Close();
} //SerializeObject

private void DeserializeObject(String filename)
{
    XmlSerializer serializer =
        new XmlSerializer(OrderedItem.class.ToType()
,
        "http://www.cpandl.com");

    // A FileStream is needed to read the XML document.
    FileStream fs = new FileStream(filename, FileMode.Open);

    // Declare an object variable of the type to be deserialized.
    OrderedItem i;

    // Deserialize the object.
    i = (OrderedItem)serializer.Deserialize(fs);
    // Insert code to use the properties and methods of the object.
} //DeserializeObject

プラットフォーム

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0

参照

XmlSerializer コンストラクタ

XmlSerializer クラスの新しいインスタンスを初期化します。
オーバーロードの一覧

名前	説明
XmlSerializer ()	XmlSerializer クラスの新しいインスタンスを初期化します。 .NET Compact Framework によってサポートされています。
XmlSerializer (Type)	指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 .NET Compact Framework によってサポートされています。
XmlSerializer (XmlTypeMapping)	ある型を別の型に割り当てるオブジェクトを指定して、XmlSerializer クラスのインスタンスを初期化します。 .NET Compact Framework によってサポートされています。
XmlSerializer (Type, String)	指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。すべての XML 要素の既定の名前空間を指定します。 .NET Compact Framework によってサポートされています。
XmlSerializer (Type, Type[])	指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。プロパティまたはフィールドが配列を返す場合、extraTypes パラメータには、その配列に挿入できるオブジェクトを指定します。 .NET Compact Framework によってサポートされています。
XmlSerializer (Type, XmlAttributeOverrides)	指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。シリアル化される各オブジェクトはそれ自体がクラスのインスタンスを含むことができ、それをこのオーバーロードによって他のクラスでオーバーライドできます。 .NET Compact Framework によってサポートされています。
XmlSerializer (Type, XmlRootAttribute)	指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。また、XML ルート要素として使用するクラスを指定します。 .NET Compact Framework によってサポートされています。
XmlSerializer (Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String)	Object 型のオブジェクトを XML ドキュメントインスタンスにシリアル化したり、XML ドキュメントインスタンスを Object 型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。シリアル化される各オブジェクトはそれ自体がクラスのインスタンスを含むことができ、それをこのオーバーロードによって他のクラスでオーバーライドします。このオーバーロードでは、すべての XML 要素の既定の名前空間、および XML ルート要素として使用するクラスも指定します。 .NET Compact Framework によってサポートされています。
XmlSerializer (Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String, String, Evidence)	指定した型のオブジェクトを XML ドキュメントインスタンスにシリアル化したり、XML ドキュメントインスタンスを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。このオーバーロードでは、シリアル化操作または逆シリアル化操作で見つかる可能性がある他の型、すべての XML 要素の既定の名前空間、XML ルート要素として使用されるクラスとその場所、およびアクセスで要求される資格情報を提供できます。