XmlSerializerとは何？わかりやすく解説 Weblio辞書

索引トップ用語の索引ランキング

XmlSerializer イベント

	名前	説明
	UnknownAttribute	逆シリアル化時に XmlSerializer が不明な型の XML 属性を認識した場合に発生します。
	UnknownElement	逆シリアル化時に XmlSerializer が不明な型の XML 要素を認識した場合に発生します。
	UnknownNode	逆シリアル化時に XmlSerializer が不明な型の XML ノードを認識した場合に発生します。
	UnreferencedObject	SOAP エンコード済み XML ストリームの逆シリアル化時に、XmlSerializer が、未使用の型または参照されていない型を認識した場合に発生します。

参照

その他の技術情報

XML シリアル化の概要
方法 : XML ストリームの代替要素名を指定する
属性を使用した XML シリアル化の制御
XML シリアル化の例
XML スキーマ定義ツール (Xsd.exe)
方法 : 派生クラスのシリアル化を制御する
<dateTimeSerialization> 要素
<xmlSerializer> 要素

XmlSerializer クラス

オブジェクトから XML ドキュメントへのシリアル化および XML ドキュメントからオブジェクトへの逆シリアル化を行います。XmlSerializer により、オブジェクトを XML にエンコードする方法を制御できます。

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

Visual Basic (宣言)

Public Class XmlSerializer

Visual Basic (使用法)

Dim instance As XmlSerializer

public class XmlSerializer

C++

public ref class XmlSerializer

public class XmlSerializer

JScript

public class XmlSerializer

解説

XML シリアル化とは、オブジェクトのパブリックプロパティとパブリックフィールドを格納したり伝送できるようにシリアル形式 (この場合は XML) に変換する処理のことです。逆シリアル化とは、その XML 出力から元の状態のオブジェクトを作り直すことです。したがって、シリアル化はオブジェクトの状態をストリームまたはバッファに保存しておく方法の 1 つと考えることができます。たとえば、ASP.NET では、XmlSerializer クラスを使用して Web サービスメッセージをエンコードします。

オブジェクトのデータは、クラス、フィールド、プロパティ、プリミティブ型、配列などのプログラミング構成要素、および XmlElement オブジェクトまたは XmlAttribute オブジェクトの形で埋め込まれている XML を使用して記述されます。属性で注釈を付けて独自のクラスを作成するか、XML スキーマ定義ツール (Xsd.exe) を使用して既存の XML スキーマ定義 (XSD: XML Schema Definition) ドキュメントに基づいたクラスを作成できます。XML スキーマがある場合は、Xsd.exe を実行して、そのスキーマに型が厳密に適合するクラスのセットを作成し、シリアル化されるときにスキーマに適合するように属性で注釈を付けることができます。

オブジェクトと XML の間でデータを転送するには、プログラミング言語構成要素から XML スキーマへの割り当てと、XML スキーマからプログラミング言語構成要素への割り当てが必要です。XmlSerializer や Xsd.exe などの関連ツールは、デザイン時および実行時に、これら 2 つの技術の間の処理を受け持ちます。デザイン時には、Xsd.exe を使用してカスタムクラスから XML スキーマドキュメント (.xsd) を作成するか、特定のスキーマからクラスを作成します。いずれの場合も、クラスにはカスタム属性を使用して注釈を付け、これによって XML スキーマシステムと共通言語ランタイム間の割り当てについて XmlSerializer に指示します。実行時には、クラスのインスタンスを、特定のスキーマに適合する XML ドキュメントにシリアル化できます。同様に、これらの XML ドキュメントをランタイムオブジェクトに逆シリアル化できます。XML スキーマはオプションであり、デザイン時または実行時に必ず用意する必要があるわけではありません。

生成される XML の制御

生成された XML を制御するために、クラスやそのメンバに特別な属性を適用できます。たとえば、異なる XML 要素名を指定するには、パブリックフィールドやパブリックプロパティに XmlElementAttribute を適用し、ElementName プロパティを設定します。類似する属性の完全な一覧については、「XML シリアル化を制御する属性」を参照してください。IXmlSerializable インターフェイスを実装して、XML 出力を制御することもできます。

生成される XML が、W3C (World Wide Web Consortium) (www.w3.org) のドキュメント『Simple Object Access Protocol (SOAP) 1.1』のセクション 5 に準拠している必要がある場合は、XmlTypeMapping を使用して XmlSerializer を構築します。エンコード済みの SOAP XML をさらに制御するには、「エンコード済み SOAP シリアル化を制御する属性」の一覧に示されている属性を使用します。

XmlSerializer を使用すると、厳密に型指定されているクラスを操作できると同時に、XML の柔軟性をも活用できます。厳密に型指定されているクラスで XmlElement 型、XmlAttribute 型、または XmlNode 型のフィールドまたはプロパティを使用すると、XML ドキュメントの一部を XML オブジェクトに直接読み込むことができます。

拡張可能な XML スキーマを使用する場合、XmlAnyElementAttribute 属性や XmlAnyAttributeAttribute 属性を使用して、元のスキーマには存在しない要素や属性をシリアル化および逆シリアル化することもできます。これらのオブジェクトを使用するには、XmlElement オブジェクトの配列を返すフィールドに XmlAnyElementAttribute を適用するか、XmlAttribute オブジェクトの配列を返すフィールドに XmlAnyAttributeAttribute を適用します。

プロパティまたはフィールドが複合オブジェクト (配列、クラスインスタンスなど) を返す場合、XmlSerializer は、これらのオブジェクトをメイン XML ドキュメント内で入れ子にされた要素に変換します。たとえば、次のコードの最初のクラスは、2 番目のクラスのインスタンスを返します。

Visual Basic

Public Class MyClass
    Public MyObjectProperty As MyObject
End Class

Public Class MyObject
    Public ObjectName As String
End Class

public class MyClass
{
    public MyObject MyObjectProperty;
}
public class MyObject
{
    public string ObjectName;
}

シリアル化された XML 出力は次のようになります。

<MyClass>
  <MyObjectProperty>
  <ObjectName>My String</ObjectName>
  </MyObjectProperty>
</MyClass>

スキーマに任意の要素 (minOccurs = '0') または既定値が含まれる場合は、2 つのオプションがあります。1 つは System.ComponentModel.DefaultValueAttribute を使用して既定値を指定する方法です。これを次のコードに示します。

Visual Basic

Public Class PurchaseOrder
    <System.ComponentModel.DefaultValueAttribute ("2002")>
 _
    Public Year As String
End Class

public class PurchaseOrder
{
    [System.ComponentModel.DefaultValueAttribute ("2002")]
    public string Year;
}

もう 1 つは、特殊パターンを使用して XmlSerializer が認識する Boolean フィールドを作成し、XmlIgnoreAttribute をそのフィールドに適用する方法です。このパターンは propertyNameSpecified の形式で作成されます。たとえば、"MyFirstName" という名前のフィールドがある場合は、"MyFirstNameSpecified" というフィールドも作成して、"MyFirstName" という XML 要素を生成するかどうかを XmlSerializer に指示します。これを次の例に示します。

Visual Basic

Public Class OptionalOrder
    ' This field's value should not be serialized 
    ' if it is uninitialized.
    Public FirstOrder As String

    ' Use the XmlIgnoreAttribute to ignore the 
    ' special field named "FirstOrderSpecified".
    <System.Xml.Serialization.XmlIgnoreAttribute> _
    Public FirstOrderSpecified As Boolean
End Class

public class OptionalOrder
{
    // This field should not be serialized 
    // if it is uninitialized.
    public string FirstOrder;

    // Use the XmlIgnoreAttribute to ignore the 
    // special field named "FirstOrderSpecified".
    [System.Xml.Serialization.XmlIgnoreAttribute]
    public bool FirstOrderSpecified;
}

既定のシリアル化のオーバーライド

また、オブジェクトとそのフィールドおよびプロパティのセットに対するシリアル化をオーバーライドすることもでき、そのためには、適切な属性の 1 つを作成し、その属性を XmlAttributes クラスのインスタンスに追加します。この方法でシリアル化をオーバーライドすることには 2 つの利点があります。第 1 に、DLL にアクセスしなくても、DLL 内のオブジェクトのシリアル化の制御および増大ができます。第 2 に、シリアル化できるクラスを 1 セット作成し、オブジェクトを複数の方法でシリアル化できます。詳細については、XmlAttributeOverrides クラスのトピックおよび「方法 : 派生クラスのシリアル化を制御する」を参照してください。

オブジェクトをシリアル化するには、Serialize メソッドを呼び出します。オブジェクトを逆シリアル化するには、Deserialize メソッドを呼び出します。

XML ドキュメントに XML 名前空間を追加する方法については、XmlSerializerNamespaces クラスのトピックを参照してください。

メモ
XmlSerializer は、IEnumerable または ICollection を実装するクラスは特別に対処します。IEnumerable を実装するクラスは、1 つのパラメータを受け取るパブリックな Add メソッドを実装している必要があります。Add メソッドのパラメータは、GetEnumerator から返された値の Current プロパティから返された型と同じであるか、またはその型の基本型の 1 つであることが必要です。IEnumerable に加えて ICollection (CollectionBase など) を実装しているクラスは、整数を受け取るパブリックな Item インデックス付きプロパティ (C# のインデクサ) および整数型のパブリック Count プロパティを持っている必要があります。Add メソッドのパラメータは、Item プロパティから返された型か、その型の基本型の 1 つと同じ型であることが必要です。ICollection を実装するクラスの場合、シリアル化する値は GetEnumerator を呼び出して取得するのではなく、インデックス付き Item プロパティから取得します。

メモ

XmlSerializer は、IEnumerable または ICollection を実装するクラスは特別に対処します。IEnumerable を実装するクラスは、1 つのパラメータを受け取るパブリックな Add メソッドを実装している必要があります。Add メソッドのパラメータは、GetEnumerator から返された値の Current プロパティから返された型と同じであるか、またはその型の基本型の 1 つであることが必要です。IEnumerable に加えて ICollection (CollectionBase など) を実装しているクラスは、整数を受け取るパブリックな Item インデックス付きプロパティ (C# のインデクサ) および整数型のパブリック Count プロパティを持っている必要があります。Add メソッドのパラメータは、Item プロパティから返された型か、その型の基本型の 1 つと同じ型であることが必要です。ICollection を実装するクラスの場合、シリアル化する値は GetEnumerator を呼び出して取得するのではなく、インデックス付き Item プロパティから取得します。

オブジェクトを逆シリアル化するには、一時ディレクトリ (TEMP 環境変数で定義) に書き込むためのアクセス許可が必要です。

動的に生成されるアセンブリ

パフォーマンスを向上するために、XML シリアル化インフラストラクチャでは、指定した型のシリアル化と逆シリアル化を行うアセンブリが動的に生成されます。それらのアセンブリはインフラストラクチャによって検索および再利用されます。この動作は、次のコンストラクタを使用するときにだけ発生します。

System.Xml.Serialization.XmlSerializer(Type)

System.Xml.Serialization.XmlSerializer(Type,String)

他のコンストラクタを使用すると、同じアセンブリの複数のバージョンが生成され、アンロードされません。その結果、メモリリークが発生し、パフォーマンスも低下します。最も簡単な解決方法は、上で挙げた 2 つのコンストラクタのいずれかを使用することです。それ以外の場合は、アセンブリを Hashtable にキャッシュする必要があります。これを次の例に示します。

Hashtable serializers = new Hashtable();

// Use the constructor that takes a type and XmlRootAttribute.
XmlSerializer s = new XmlSerializer(typeof(MyClass), myRoot);

// Implement a method named GenerateKey that creates unique keys 
// for each instance of the XmlSerializer. The code should take 
// into account all parameters passed to the XmlSerializer 
// constructor.
object key = GenerateKey(typeof(MyClass), myRoot);

// Check the local cache for a matching serializer.
XmlSerializer ser = (XmlSerializer)serializers[key];
if (ser == null) 
{
    ser = new XmlSerializer(typeof(MyClass), myRoot);
    // Cache the serializer.
    serializers[key] = ser;
}
else
{
    // Use the serializer to serialize, or deserialize.
}

Visual Basic

Dim serializers As New Hashtable()

' Use the constructor that takes a type and XmlRootAttribute.
Dim s As New XmlSerializer(GetType([MyClass]),
 myRoot)

' Implement a method named GenerateKey that creates unique keys 
' for each instance of the XmlSerializer. The code should take 
' into account all parameters passed to the XmlSerializer 
' constructor.
Dim key As Object = GenerateKey(GetType([MyClass]),
 myRoot)

' Check the local cache for a matching serializer.
Dim ser As XmlSerializer = CType(serializers(key),
 XmlSerializer)

If ser Is Nothing Then
    ser = New XmlSerializer(GetType([MyClass]),
 myRoot)
    ' Cache the serializer.
    serializers(key) = ser
Else 
    ' Use the serializer to serialize, or deserialize.
End If

ArrayList およびジェネリックリストのシリアル化

次のようなデータについては、XmlSerializer でシリアル化または逆シリアル化することはできません。

ArrayList の配列。
List の配列。

使用例

2 つのメインクラス、PurchaseOrder と Test が含まれている例を次に示します。PurchaseOrder クラスには、1 件の購入に関する情報が格納されています。Test クラスには発注書を作成するメソッドと、作成された発注書を読み取るメソッドが含まれています。

Visual Basic

Imports System
Imports System.Xml
Imports System.Xml.Serialization
Imports System.IO
Imports Microsoft.VisualBasic


' The XmlRootAttribute allows you to set an alternate name
' (PurchaseOrder) of the XML element, the element namespace; by
' default, the XmlSerializer uses the class name. The attribute
' also allows you to set the XML namespace for the element.  Lastly
,
' the attribute sets the IsNullable property, which specifies whether
' the xsi:null attribute appears if the class instance is set to
' a null reference. 
<XmlRootAttribute("PurchaseOrder", _
 Namespace := "http://www.cpandl.com",
 IsNullable := False)> _
Public Class PurchaseOrder
    
    Public ShipTo As Address
    Public OrderDate As String
    ' The XmlArrayAttribute changes the XML element name
    ' from the default of "OrderedItems" to "Items".
 
    <XmlArrayAttribute("Items")> _
    Public OrderedItems() As OrderedItem
    Public SubTotal As Decimal
    Public ShipCost As Decimal
    Public TotalCost As Decimal
End Class 'PurchaseOrder


Public Class Address
    ' The XmlAttribute instructs the XmlSerializer to serialize the
 Name
    ' field as an XML attribute instead of an XML element (the default
    ' behavior). 
    <XmlAttribute()> _
    Public Name As String
    Public Line1 As String
    
    ' Setting the IsNullable property to false instructs the
    ' XmlSerializer that the XML attribute will not appear if
    ' the City field is set to a null reference. 
    <XmlElementAttribute(IsNullable := False)> _
    Public City As String
    Public State As String
    Public Zip As String
End Class 'Address


Public Class OrderedItem
    Public ItemName As String
    Public Description As String
    Public UnitPrice As Decimal
    Public Quantity As Integer
    Public LineTotal As Decimal
    
    
    ' Calculate is a custom method that calculates the price per item
,
    ' and stores the value in a field. 
    Public Sub Calculate()
        LineTotal = UnitPrice * Quantity
    End Sub 'Calculate
End Class 'OrderedItem


Public Class Test
    
   Public Shared Sub Main()
      ' Read and write purchase orders.
      Dim t As New Test()
      t.CreatePO("po.xml")
      t.ReadPO("po.xml")
   End Sub 'Main
    
   Private Sub CreatePO(filename As
 String)
      ' Create an instance of the XmlSerializer class;
      ' specify the type of object to serialize.
      Dim serializer As New
 XmlSerializer(GetType(PurchaseOrder))
      Dim writer As New
 StreamWriter(filename)
      Dim po As New PurchaseOrder()
        
      ' Create an address to ship and bill to.
      Dim billAddress As New
 Address()
      billAddress.Name = "Teresa Atkinson"
      billAddress.Line1 = "1 Main St."
      billAddress.City = "AnyTown"
      billAddress.State = "WA"
      billAddress.Zip = "00000"
      ' Set ShipTo and BillTo to the same addressee.
      po.ShipTo = billAddress
      po.OrderDate = System.DateTime.Now.ToLongDateString()
        
      ' Create an OrderedItem object.
      Dim i1 As New OrderedItem()
      i1.ItemName = "Widget S"
      i1.Description = "Small widget"
      i1.UnitPrice = CDec(5.23)
      i1.Quantity = 3
      i1.Calculate()
        
      ' Insert the item into the array.
      Dim items(0) As OrderedItem
      items(0) = i1
      po.OrderedItems = items
      ' Calculate the total cost.
      Dim subTotal As New
 Decimal()
      Dim oi As OrderedItem
      For Each oi In  items
         subTotal += oi.LineTotal
      Next oi
      po.SubTotal = subTotal
      po.ShipCost = CDec(12.51)
      po.TotalCost = po.SubTotal + po.ShipCost
      ' Serialize the purchase order, and close the TextWriter.
      serializer.Serialize(writer, po)
      writer.Close()
   End Sub 'CreatePO
    
   Protected Sub ReadPO(filename As
 String)
      ' Create an instance of the XmlSerializer class;
      ' specify the type of object to be deserialized.
      Dim serializer As New
 XmlSerializer(GetType(PurchaseOrder))
      ' If the XML document has been altered with unknown
      ' nodes or attributes, handle them with the
      ' UnknownNode and UnknownAttribute events.
      AddHandler serializer.UnknownNode, AddressOf
 serializer_UnknownNode
      AddHandler serializer.UnknownAttribute, AddressOf
 serializer_UnknownAttribute
      
      ' 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 po As PurchaseOrder
      ' Use the Deserialize method to restore the object's state with
      ' data from the XML document. 
      po = CType(serializer.Deserialize(fs), PurchaseOrder)
      ' Read the order date.
      Console.WriteLine(("OrderDate: " & po.OrderDate))
        
      ' Read the shipping address.
      Dim shipTo As Address = po.ShipTo
      ReadAddress(shipTo, "Ship To:")
      ' Read the list of ordered items.
      Dim items As OrderedItem() = po.OrderedItems
      Console.WriteLine("Items to be shipped:")
      Dim oi As OrderedItem
      For Each oi In  items
         Console.WriteLine((ControlChars.Tab & oi.ItemName & ControlChars.Tab
 & _
         oi.Description & ControlChars.Tab & oi.UnitPrice & ControlChars.Tab
 & _
         oi.Quantity & ControlChars.Tab & oi.LineTotal))
      Next oi
      ' Read the subtotal, shipping cost, and total cost.
      Console.WriteLine(( New String(ControlChars.Tab,
 5) & _
      " Subtotal"  & ControlChars.Tab & po.SubTotal))
      Console.WriteLine(New String(ControlChars.Tab,
 5) & _
      " Shipping" & ControlChars.Tab & po.ShipCost
 )
      Console.WriteLine( New String(ControlChars.Tab,
 5) & _
      " Total" &  New String(ControlChars.Tab,
 2) & po.TotalCost)
    End Sub 'ReadPO
    
    Protected Sub ReadAddress(a As
 Address, label As String)
      ' Read the fields of the Address object.
      Console.WriteLine(label)
      Console.WriteLine(ControlChars.Tab & a.Name)
      Console.WriteLine(ControlChars.Tab & a.Line1)
      Console.WriteLine(ControlChars.Tab & a.City)
      Console.WriteLine(ControlChars.Tab & a.State)
      Console.WriteLine(ControlChars.Tab & a.Zip)
      Console.WriteLine()
    End Sub 'ReadAddress
        
    Private Sub serializer_UnknownNode(sender
 As Object, e As XmlNodeEventArgs)
        Console.WriteLine(("Unknown Node:" & e.Name
 & ControlChars.Tab & e.Text))
    End Sub 'serializer_UnknownNode
    
    
    Private Sub serializer_UnknownAttribute(sender
 As Object, e As XmlAttributeEventArgs)
        Dim attr As System.Xml.XmlAttribute
 = e.Attr
        Console.WriteLine(("Unknown attribute " &
 attr.Name & "='" & attr.Value & "'"))
    End Sub 'serializer_UnknownAttribute
End Class 'Test

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

/* The XmlRootAttribute allows you to set an alternate name 
   (PurchaseOrder) of the XML element, the element namespace;
 by 
   default, the XmlSerializer uses the class
 name. The attribute 
   also allows you to set the XML namespace
 for the element.  Lastly,
   the attribute sets the IsNullable property, which specifies whether 
   the xsi:null attribute appears if the class
 instance is set to 
   a null reference. */
[XmlRootAttribute("PurchaseOrder", Namespace="http://www.cpandl.com",
 
IsNullable = false)]
public class PurchaseOrder
{
   public Address ShipTo;
   public string OrderDate; 
   /* The XmlArrayAttribute changes the XML element name
    from the default of "OrderedItems" to "Items".
 */
   [XmlArrayAttribute("Items")]
   public OrderedItem[] OrderedItems;
   public decimal SubTotal;
   public decimal ShipCost;
   public decimal TotalCost;   
}
 
public class Address
{
   /* The XmlAttribute instructs the XmlSerializer to serialize the Name
      field as an XML attribute instead of an XML element (the default
      behavior). */
   [XmlAttribute]
   public string Name;
   public string Line1;

   /* Setting the IsNullable property to false instructs the 
      XmlSerializer that the XML attribute will not appear if
 
      the City field is set to a null reference.
 */
   [XmlElementAttribute(IsNullable = false)]
   public string City;
   public string State;
   public string Zip;
}
 
public class OrderedItem
{
   public string ItemName;
   public string Description;
   public decimal UnitPrice;
   public int Quantity;
   public decimal LineTotal;

   /* Calculate is a custom method that calculates the price per item,
      and stores the value in a field. */
   public void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
}
 
public class Test
{
   public static void Main()
   {
      // Read and write purchase orders.
      Test t = new Test();
      t.CreatePO("po.xml");
      t.ReadPO("po.xml");
   }

   private void CreatePO(string
 filename)
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to serialize.
      XmlSerializer serializer = 
      new XmlSerializer(typeof(PurchaseOrder));
      TextWriter writer = new StreamWriter(filename);
      PurchaseOrder po=new PurchaseOrder();
       
      // Create an address to ship and bill to.
      Address billAddress = new Address();
      billAddress.Name = "Teresa Atkinson";
      billAddress.Line1 = "1 Main St.";
      billAddress.City = "AnyTown";
      billAddress.State = "WA";
      billAddress.Zip = "00000";
      // Set ShipTo and BillTo to the same addressee.
      po.ShipTo = billAddress;
      po.OrderDate = System.DateTime.Now.ToLongDateString();
 
      // Create an OrderedItem object.
      OrderedItem i1 = new OrderedItem();
      i1.ItemName = "Widget S";
      i1.Description = "Small widget";
      i1.UnitPrice = (decimal) 5.23;
      i1.Quantity = 3;
      i1.Calculate();
 
      // Insert the item into the array.
      OrderedItem [] items = {i1};
      po.OrderedItems = items;
      // Calculate the total cost.
      decimal subTotal = new decimal();
      foreach(OrderedItem oi in items)
      {
         subTotal += oi.LineTotal;
      }
      po.SubTotal = subTotal;
      po.ShipCost = (decimal) 12.51; 
      po.TotalCost = po.SubTotal + po.ShipCost; 
      // Serialize the purchase order, and close the TextWriter.
      serializer.Serialize(writer, po);
      writer.Close();
   }
 
   protected void ReadPO(string
 filename)
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to be deserialized.
      XmlSerializer serializer = new XmlSerializer(typeof(PurchaseOrder));
      /* If the XML document has been altered with unknown 
      nodes or attributes, handle them with the 
      UnknownNode and UnknownAttribute events.*/
      serializer.UnknownNode+= new 
      XmlNodeEventHandler(serializer_UnknownNode);
      serializer.UnknownAttribute+= new 
      XmlAttributeEventHandler(serializer_UnknownAttribute);
   
      // 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.
      PurchaseOrder po;
      /* Use the Deserialize method to restore the object's state with
      data from the XML document. */
      po = (PurchaseOrder) serializer.Deserialize(fs);
      // Read the order date.
      Console.WriteLine ("OrderDate: " + po.OrderDate);
  
      // Read the shipping address.
      Address shipTo = po.ShipTo;
      ReadAddress(shipTo, "Ship To:");
      // Read the list of ordered items.
      OrderedItem [] items = po.OrderedItems;
      Console.WriteLine("Items to be shipped:");
      foreach(OrderedItem oi in items)
      {
         Console.WriteLine("\t"+
         oi.ItemName + "\t" + 
         oi.Description + "\t" +
         oi.UnitPrice + "\t" +
         oi.Quantity + "\t" +
         oi.LineTotal);
      }
      // Read the subtotal, shipping cost, and total cost.
      Console.WriteLine("\t\t\t\t\t Subtotal\t" + po.SubTotal);
      Console.WriteLine("\t\t\t\t\t Shipping\t" + po.ShipCost); 
      Console.WriteLine("\t\t\t\t\t Total\t\t" + po.TotalCost);
   }
 
   protected void ReadAddress(Address a, string
 label)
   {
      // Read the fields of the Address object.
      Console.WriteLine(label);
      Console.WriteLine("\t"+ a.Name );
      Console.WriteLine("\t" + a.Line1);
      Console.WriteLine("\t" + a.City);
      Console.WriteLine("\t" + a.State);
      Console.WriteLine("\t" + a.Zip );
      Console.WriteLine();
   }

   private void serializer_UnknownNode
   (object sender, XmlNodeEventArgs e)
   {
      Console.WriteLine("Unknown Node:" +   e.Name + "\t" + e.Text);
   }

   private void serializer_UnknownAttribute
   (object sender, XmlAttributeEventArgs e)
   {
      System.Xml.XmlAttribute attr = e.Attr;
      Console.WriteLine("Unknown attribute " + 
      attr.Name + "='" + attr.Value + "'");
   }
}

C++

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

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

/* The XmlRootAttribute allows you to set an alternate name 
   (PurchaseOrder) of the XML element, the element namespace;
 by 
   default, the XmlSerializer uses the class
 name. The attribute 
   also allows you to set the XML namespace
 for the element.  Lastly,
   the attribute sets the IsNullable property, which specifies whether 
   the xsi:null attribute appears if the class
 instance is set to 
   a null reference. */

[XmlRootAttribute("PurchaseOrder",Namespace="http://www.cpandl.com"
,
IsNullable=false)]
public ref class PurchaseOrder
{
public:
   Address^ ShipTo;
   String^ OrderDate;

   /* The XmlArrayAttribute changes the XML element name
       from the default of "OrderedItems" to "Items".
 */

   [XmlArrayAttribute("Items")]
   array<OrderedItem^>^OrderedItems;
   Decimal SubTotal;
   Decimal ShipCost;
   Decimal TotalCost;
};

public ref class Address
{
public:

   /* The XmlAttribute instructs the XmlSerializer to serialize the Name
         field as an XML attribute instead of an XML element (the default
         behavior). */

   [XmlAttributeAttribute]
   String^ Name;
   String^ Line1;

   /* Setting the IsNullable property to false instructs the 
         XmlSerializer that the XML attribute will not appear if
 
         the City field is set to a null reference.
 */

   [XmlElementAttribute(IsNullable=false)]
   String^ City;
   String^ State;
   String^ Zip;
};

public ref class OrderedItem
{
public:
   String^ ItemName;
   String^ Description;
   Decimal UnitPrice;
   int Quantity;
   Decimal LineTotal;

   /* Calculate is a custom method that calculates the price per item,
         and stores the value in a field. */
   void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }

};

public ref class Test
{
public:
   static void main()
   {
      // Read and write purchase orders.
      Test^ t = gcnew Test;
      t->CreatePO( "po.xml" );
      t->ReadPO( "po.xml" );
   }

private:
   void CreatePO( String^ filename )
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to serialize.
      XmlSerializer^ serializer = gcnew XmlSerializer( PurchaseOrder::typeid );
      TextWriter^ writer = gcnew StreamWriter( filename );
      PurchaseOrder^ po = gcnew PurchaseOrder;

      // Create an address to ship and bill to.
      Address^ billAddress = gcnew Address;
      billAddress->Name = "Teresa Atkinson";
      billAddress->Line1 = "1 Main St.";
      billAddress->City = "AnyTown";
      billAddress->State = "WA";
      billAddress->Zip = "00000";

      // Set ShipTo and BillTo to the same addressee.
      po->ShipTo = billAddress;
      po->OrderDate = System::DateTime::Now.ToLongDateString();

      // Create an OrderedItem object.
      OrderedItem^ i1 = gcnew OrderedItem;
      i1->ItemName = "Widget S";
      i1->Description = "Small widget";
      i1->UnitPrice = (Decimal)5.23;
      i1->Quantity = 3;
      i1->Calculate();

      // Insert the item into the array.
      array<OrderedItem^>^items = {i1};
      po->OrderedItems = items;

      // Calculate the total cost.
      Decimal subTotal = Decimal(0);
      System::Collections::IEnumerator^ myEnum = items->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         OrderedItem^ oi = safe_cast<OrderedItem^>(myEnum->Current);
         subTotal = subTotal + oi->LineTotal;
      }

      po->SubTotal = subTotal;
      po->ShipCost = (Decimal)12.51;
      po->TotalCost = po->SubTotal + po->ShipCost;

      // Serialize the purchase order, and close the TextWriter.
      serializer->Serialize( writer, po );
      writer->Close();
   }

protected:
   void ReadPO( String^ filename )
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to be deserialized.
      XmlSerializer^ serializer = gcnew XmlSerializer( PurchaseOrder::typeid );

      /* If the XML document has been altered with unknown 
            nodes or attributes, handle them with the 
            UnknownNode and UnknownAttribute events.*/
      serializer->UnknownNode += gcnew XmlNodeEventHandler( this,
 &Test::serializer_UnknownNode );
      serializer->UnknownAttribute += gcnew XmlAttributeEventHandler( this,
 &Test::serializer_UnknownAttribute );

      // 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.
      PurchaseOrder^ po;

      /* Use the Deserialize method to restore the object's state with
            data from the XML document. */
      po = dynamic_cast<PurchaseOrder^>(serializer->Deserialize( fs ));

      // Read the order date.
      Console::WriteLine( "OrderDate: {0}", po->OrderDate );

      // Read the shipping address.
      Address^ shipTo = po->ShipTo;
      ReadAddress( shipTo, "Ship To:" );

      // Read the list of ordered items.
      array<OrderedItem^>^items = po->OrderedItems;
      Console::WriteLine( "Items to be shipped:" );
      System::Collections::IEnumerator^ myEnum1 = items->GetEnumerator();
      while ( myEnum1->MoveNext() )
      {
         OrderedItem^ oi = safe_cast<OrderedItem^>(myEnum1->Current);
         Console::WriteLine( "\t{0}\t{1}\t{2}\t{3}\t{4}", oi->ItemName,
 oi->Description, oi->UnitPrice, oi->Quantity, oi->LineTotal );
      }

      Console::WriteLine( "\t\t\t\t\t Subtotal\t{0}", po->SubTotal );
      Console::WriteLine( "\t\t\t\t\t Shipping\t{0}", po->ShipCost );
      Console::WriteLine( "\t\t\t\t\t Total\t\t{0}", po->TotalCost );
   }

   void ReadAddress( Address^ a, String^ label )
   {
      // Read the fields of the Address object.
      Console::WriteLine( label );
      Console::WriteLine( "\t{0}", a->Name );
      Console::WriteLine( "\t{0}", a->Line1 );
      Console::WriteLine( "\t{0}", a->City );
      Console::WriteLine( "\t{0}", a->State );
      Console::WriteLine( "\t{0}", a->Zip );
      Console::WriteLine();
   }

private:
   void serializer_UnknownNode( Object^ /*sender*/, XmlNodeEventArgs^
 e )
   {
      Console::WriteLine( "Unknown Node:{0}\t{1}", e->Name, e->Text
 );
   }

   void serializer_UnknownAttribute( Object^ /*sender*/, XmlAttributeEventArgs^
 e )
   {
      System::Xml::XmlAttribute^ attr = e->Attr;
      Console::WriteLine( "Unknown attribute {0}='{1}'", attr->Name,
 attr->Value );
   }
};

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

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

/* The XmlRootAttribute allows you to set an alternate name 
   (PurchaseOrder) of the XML element, the element namespace;
 by 
   default, the XmlSerializer uses the class
 name. The attribute 
   also allows you to set the XML namespace
 for the element.  Lastly,
   the attribute sets the IsNullable property, which specifies whether 
   the xsi:null attribute appears if the class
 instance is set to 
   a null reference. */
/** @attribute XmlRootAttribute("PurchaseOrder",
    Namespace = "http://www.cpandl.com", IsNullable = false)
 */
public class PurchaseOrder
{
    public Address shipTo;
    public String orderDate;
    /* The XmlArrayAttribute changes the XML element name
       from the default of "OrderedItems" to "Items".
 */
    /** @attribute XmlArrayAttribute("Items")
     */
    public OrderedItem orderedItems[];
    public System.Decimal subTotal;
    public System.Decimal shipCost;
    public System.Decimal totalCost;
} //PurchaseOrder

public class Address
{
    /* The XmlAttribute instructs the XmlSerializer to serialize the Name
       field as an XML attribute instead of an XML element (the default
       behavior). */
    /** @attribute XmlAttribute()
     */
    public String name;
    public String line1;
    
    /* Setting the IsNullable property to false instructs the
 
       XmlSerializer that the XML attribute will not appear if
 
       the City field is set to a null reference.
 */
    /** @attribute XmlElementAttribute(IsNullable = false)
     */
    public String city;
    public String state;
    public String zip;
} //Address

public class OrderedItem
{
    public String itemName;
    public String description;
    public System.Decimal unitPrice;
    public int quantity;
    public System.Decimal lineTotal;

    /* Calculate is a custom method that calculates the price per item,
       and stores the value in a field. */
    public void Calculate()
    {
        lineTotal = Decimal.Multiply(unitPrice, Convert.ToDecimal(quantity));
    } //Calculate
} //OrderedItem

public class Test
{
    public static void main(String[]
 args)
    {
        // Read and write purchase orders.
        Test t = new Test();
        t.CreatePO("po.xml");
        t.ReadPO("po.xml");
    } //main

    private void CreatePO(String fileName)
    {
        // Create an instance of the XmlSerializer class;
        // specify the type of object to serialize.
        XmlSerializer serializer =
            new XmlSerializer(PurchaseOrder.class.ToType());
        TextWriter writer = new StreamWriter(fileName);
        PurchaseOrder po = new PurchaseOrder();

        // Create an address to ship and bill to.
        Address billAddress = new Address();
        billAddress.name = "Teresa Atkinson";
        billAddress.line1 = "1 Main St.";
        billAddress.city = "AnyTown";
        billAddress.state = "WA";
        billAddress.zip = "00000";

        // Set ShipTo and BillTo to the same addressee.
        po.shipTo = billAddress;
        po.orderDate = System.DateTime.get_Now().ToLongDateString();

        // Create an OrderedItem object.
        OrderedItem i1 = new OrderedItem();
        i1.itemName = "Widget S";
        i1.description = "Small widget";
        i1.unitPrice = Convert.ToDecimal(5.23);
        i1.quantity = 3;
        i1.Calculate();

        // Insert the item into the array.
        OrderedItem items[] = { i1 };
        po.orderedItems = items;

        // Calculate the total cost.
        System.Decimal subTotal = new System.Decimal();
        for (int iCtr = 0; iCtr < items.length;
 iCtr++) {
            OrderedItem oi = items[iCtr];
            subTotal = Decimal.Add(subTotal, oi.lineTotal);
        }

        po.subTotal = subTotal;
        po.shipCost = Convert.ToDecimal(12.51);
        po.totalCost = Decimal.Add(po.subTotal, po.shipCost);

        // Serialize the purchase order, and close the TextWriter.
        serializer.Serialize(writer, po);
        writer.Close();
    } //CreatePO

    protected void ReadPO(String fileName)
    {
        // Create an instance of the XmlSerializer class;
        // specify the type of object to be deserialized.
        XmlSerializer serializer =
            new XmlSerializer(PurchaseOrder.class.ToType());
        /* If the XML document has been altered with unknown 
           nodes or attributes, handle them with the 
           UnknownNode and UnknownAttribute events.*/
        serializer.add_UnknownNode(
            new XmlNodeEventHandler(Serializer_UnknownNode));
        serializer.add_UnknownAttribute(
            new XmlAttributeEventHandler(Serializer_UnknownAttribute));

        // 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.
        PurchaseOrder po;

        /* Use the Deserialize method to restore the object's state with
           data from the XML document. */
        po = (PurchaseOrder)serializer.Deserialize(fs);

        // Read the order date.
        Console.WriteLine("OrderDate: " + po.orderDate);

        // Read the shipping address.
        Address shipTo = po.shipTo;
        ReadAddress(shipTo, "Ship To:");

        // Read the list of ordered items.
        OrderedItem items[] = po.orderedItems;
        Console.WriteLine("Items to be shipped:");
        for (int iCtr = 0; iCtr < items.length;
 iCtr++) {
            OrderedItem oi = items[iCtr];
            Console.WriteLine("\t" + oi.itemName + "\t"
                + oi.description + "\t" + oi.unitPrice + "\t"
                + oi.quantity + "\t" + oi.lineTotal);
        }
        // Read the subtotal, shipping cost, and total cost.
        Console.WriteLine("\t\t\t\t\t Subtotal\t" + po.subTotal);
        Console.WriteLine("\t\t\t\t\t Shipping\t" + po.shipCost);
        Console.WriteLine("\t\t\t\t\t Total\t\t" + po.totalCost);
    } //ReadPO

    protected void ReadAddress(Address a, String
 label)
    {
        // Read the fields of the Address object.
        Console.WriteLine(label);
        Console.WriteLine("\t" + a.name);
        Console.WriteLine("\t" + a.line1);
        Console.WriteLine("\t" + a.city);
        Console.WriteLine("\t" + a.state);
        Console.WriteLine("\t" + a.zip);
        Console.WriteLine();
    } //ReadAddress

    private void Serializer_UnknownNode(Object
 sender, XmlNodeEventArgs e)
    {
        Console.WriteLine("Unknown Node:" + e.get_Name() + "\t"
 + e.get_Text());
    } //Serializer_UnknownNode

    private void Serializer_UnknownAttribute(Object
 sender,
        XmlAttributeEventArgs e)
    {
        System.Xml.XmlAttribute attr = e.get_Attr();
        Console.WriteLine("Unknown attribute " + attr.get_Name() + "='"
            + attr.get_Value() + "'");
    } //Serializer_UnknownAttribute
} //Test

継承階層

System.Object
System.Xml.Serialization.XmlSerializer

スレッドセーフ

この型は、マルチスレッド操作に対して安全です。

プラットフォーム

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 メンバ
System.Xml.Serialization 名前空間
XmlAttributeOverrides クラス
XmlAttributes クラス
XmlSerializer クラス
XmlAttributes.XmlText プロパティ
XmlAttributes クラス
その他の技術情報
XML シリアル化の概要
方法 : XML ストリームの代替要素名を指定する
属性を使用した XML シリアル化の制御
XML シリアル化の例
XML スキーマ定義ツール (Xsd.exe)
方法 : 派生クラスのシリアル化を制御する
<dateTimeSerialization> 要素
<xmlSerializer> 要素

XmlSerializer コンストラクタ ()

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

XmlSerializer クラスの新しいインスタンスを初期化します。

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

Visual Basic (宣言)

Protected Sub New

Visual Basic (使用法)

Dim instance As New XmlSerializer

protected XmlSerializer ()

C++

protected:
XmlSerializer ()

protected XmlSerializer ()

JScript

protected function XmlSerializer ()

プラットフォーム

バージョン情報

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

参照

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

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

プラットフォーム

バージョン情報

.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 ルート要素として使用されるクラスとその場所、およびアクセスで要求される資格情報を提供できます。

参照

XmlSerializer メソッド

パブリックメソッドパブリックメソッド

( プロテクトメソッドも参照)

	名前	説明
	CanDeserialize	XmlSerializer が、指定された XML ドキュメントを逆シリアル化できるかどうかを示す値を取得します。
	Deserialize	オーバーロードされます。 XML ドキュメントを逆シリアル化します。
	Equals	オーバーロードされます。 2 つの Object インスタンスが等しいかどうかを判断します。 ( Object から継承されます。)
	FromMappings	オーバーロードされます。指定した割り当てから XmlSerializer クラスのインスタンスを返します。
	FromTypes	型の配列から作成された、XmlSerializer オブジェクトの配列を返します。
	GenerateSerializer	オーバーロードされます。型指定されたシリアライザを格納しているアセンブリを返します。
	GetHashCode	特定の型のハッシュ関数として機能します。GetHashCode は、ハッシュアルゴリズムや、ハッシュテーブルのようなデータ構造での使用に適しています。 ( Object から継承されます。)
	GetType	現在のインスタンスの Type を取得します。 ( Object から継承されます。)
	GetXmlSerializerAssemblyName	オーバーロードされます。特定の型のシリアル化または逆シリアル化のために特に作成された 1 つ以上のバージョンの XmlSerializer を格納しているアセンブリの名前を返します。
	ReferenceEquals	指定した複数の Object インスタンスが同一かどうかを判断します。 ( Object から継承されます。)
	Serialize	オーバーロードされます。オブジェクトを XML ドキュメントにシリアル化します。
	ToString	現在の Object を表す String を返します。 ( Object から継承されます。)

プロテクトメソッド

	名前	説明
	CreateReader	シリアル化される XML ドキュメントを読み取るために使用されるオブジェクトを返します。
	CreateWriter	派生クラスでオーバーライドされた場合、オブジェクトのシリアル化に使用されるライタを返します。
	Deserialize	オーバーロードされます。 XML ドキュメントを逆シリアル化します。
	Finalize	Object がガベージコレクションにより収集される前に、その Object がリソースを解放し、その他のクリーンアップ操作を実行できるようにします。 ( Object から継承されます。)
	MemberwiseClone	現在の Object の簡易コピーを作成します。 ( Object から継承されます。)
	Serialize	オーバーロードされます。オブジェクトを XML ドキュメントにシリアル化します。

参照

その他の技術情報

XmlSerializer メンバ

オブジェクトから XML ドキュメントへのシリアル化および XML ドキュメントからオブジェクトへの逆シリアル化を行います。XmlSerializer により、オブジェクトを XML にエンコードする方法を制御できます。

XmlSerializer データ型で公開されるメンバを以下の表に示します。

パブリックコンストラクタ

( プロテクトコンストラクタも参照)

	名前	説明
	XmlSerializer	オーバーロードされます。 XmlSerializer クラスの新しいインスタンスを初期化します。

プロテクトコンストラクタ

	名前	説明
	XmlSerializer	オーバーロードされます。 XmlSerializer クラスの新しいインスタンスを初期化します。

パブリックメソッド

( プロテクトメソッドも参照)

	名前	説明
	CanDeserialize	XmlSerializer が、指定された XML ドキュメントを逆シリアル化できるかどうかを示す値を取得します。
	Deserialize	オーバーロードされます。 XML ドキュメントを逆シリアル化します。
	Equals	オーバーロードされます。 2 つの Object インスタンスが等しいかどうかを判断します。 (Object から継承されます。)
	FromMappings	オーバーロードされます。指定した割り当てから XmlSerializer クラスのインスタンスを返します。
	FromTypes	型の配列から作成された、XmlSerializer オブジェクトの配列を返します。
	GenerateSerializer	オーバーロードされます。型指定されたシリアライザを格納しているアセンブリを返します。
	GetHashCode	特定の型のハッシュ関数として機能します。GetHashCode は、ハッシュアルゴリズムや、ハッシュテーブルのようなデータ構造での使用に適しています。 (Object から継承されます。)
	GetType	現在のインスタンスの Type を取得します。 (Object から継承されます。)
	GetXmlSerializerAssemblyName	オーバーロードされます。特定の型のシリアル化または逆シリアル化のために特に作成された 1 つ以上のバージョンの XmlSerializer を格納しているアセンブリの名前を返します。
	ReferenceEquals	指定した複数の Object インスタンスが同一かどうかを判断します。 (Object から継承されます。)
	Serialize	オーバーロードされます。オブジェクトを XML ドキュメントにシリアル化します。
	ToString	現在の Object を表す String を返します。 (Object から継承されます。)

プロテクトメソッド

	名前	説明
	CreateReader	シリアル化される XML ドキュメントを読み取るために使用されるオブジェクトを返します。
	CreateWriter	派生クラスでオーバーライドされた場合、オブジェクトのシリアル化に使用されるライタを返します。
	Deserialize	オーバーロードされます。 XML ドキュメントを逆シリアル化します。
	Finalize	Object がガベージコレクションにより収集される前に、その Object がリソースを解放し、その他のクリーンアップ操作を実行できるようにします。 (Object から継承されます。)
	MemberwiseClone	現在の Object の簡易コピーを作成します。 (Object から継承されます。)
	Serialize	オーバーロードされます。オブジェクトを XML ドキュメントにシリアル化します。

パブリックイベント

	名前	説明
	UnknownAttribute	逆シリアル化時に XmlSerializer が不明な型の XML 属性を認識した場合に発生します。
	UnknownElement	逆シリアル化時に XmlSerializer が不明な型の XML 要素を認識した場合に発生します。
	UnknownNode	逆シリアル化時に XmlSerializer が不明な型の XML ノードを認識した場合に発生します。
	UnreferencedObject	SOAP エンコード済み XML ストリームの逆シリアル化時に、XmlSerializer が、未使用の型または参照されていない型を認識した場合に発生します。

参照

その他の技術情報

>> 「XmlSerializer」を含む用語の索引
XmlSerializerのページへのリンク

XmlSerializerとは？わかりやすく解説

XmlSerializer イベント

関連項目

その他の技術情報

XmlSerializer クラス

動的に生成されるアセンブリ

XmlSerializer コンストラクタ ()

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

XmlSerializer コンストラクタ (Type)

XmlSerializer コンストラクタ (XmlTypeMapping)

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

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

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

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

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

XmlSerializer コンストラクタ

関連項目

XmlSerializer メソッド

関連項目

その他の技術情報

XmlSerializer メンバ

関連項目

その他の技術情報

「XmlSerializer」の関連用語


	© 2025 Microsoft.All rights reserved.

XmlSerializerとは？ わかりやすく解説

XmlSerializer イベント

関連項目

その他の技術情報

XmlSerializer クラス

動的に生成されるアセンブリ

XmlSerializer コンストラクタ ()

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

XmlSerializer コンストラクタ (Type)

XmlSerializer コンストラクタ (XmlTypeMapping)

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

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

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

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

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

XmlSerializer コンストラクタ

関連項目

XmlSerializer メソッド

関連項目

その他の技術情報

XmlSerializer メンバ

関連項目

その他の技術情報

急上昇のことば

「XmlSerializer」の関連用語

XmlSerializerとは？わかりやすく解説