XmlSerializer コンストラクター
定義
重要
一部の情報は、リリース前に大きく変更される可能性があるプレリリースされた製品に関するものです。 Microsoft は、ここに記載されている情報について、明示または黙示を問わず、一切保証しません。
XmlSerializer クラスの新しいインスタンスを初期化します。
オーバーロード
XmlSerializer() |
XmlSerializer クラスの新しいインスタンスを初期化します。 |
XmlSerializer(Type) |
指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 |
XmlSerializer(XmlTypeMapping) |
ある型を別の型にマップするオブジェクトを指定して、XmlSerializer クラスのインスタンスを初期化します。 |
XmlSerializer(Type, String) |
指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 すべての XML 要素の既定の名前空間を指定します。 |
XmlSerializer(Type, Type[]) |
指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 プロパティまたはフィールドが配列を返す場合、 |
XmlSerializer(Type, XmlAttributeOverrides) |
指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 シリアル化される各オブジェクトはそれ自体がクラスのインスタンスを含むことができ、それをこのオーバーロードによって他のクラスでオーバーライドします。 |
XmlSerializer(Type, XmlRootAttribute) |
指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 また、XML ルート要素として使用するクラスを指定します。 |
XmlSerializer(Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String) |
Object 型のオブジェクトを XML ドキュメント インスタンスにシリアル化したり、XML ドキュメント インスタンスを Object 型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 シリアル化される各オブジェクトはそれ自体がクラスのインスタンスを含むことができ、それをこのオーバーロードによって他のクラスでオーバーライドします。 このオーバーロードでは、すべての XML 要素の既定の名前空間、および XML ルート要素として使用するクラスも指定します。 |
XmlSerializer(Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String, String) |
Object 型のオブジェクトを XML ドキュメント インスタンスにシリアル化したり、XML ドキュメント インスタンスを Object 型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 シリアル化される各オブジェクトはそれ自体がクラスのインスタンスを含むことができ、それをこのオーバーロードによって他のクラスでオーバーライドします。 このオーバーロードでは、すべての XML 要素の既定の名前空間、および XML ルート要素として使用するクラスも指定します。 |
XmlSerializer(Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String, String, Evidence) |
互換性のために残されています。
指定した型のオブジェクトを XML ドキュメント インスタンスにシリアル化したり、XML ドキュメント インスタンスを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 このオーバーロードでは、シリアル化操作または逆シリアル化操作で見つかる可能性がある他の型、すべての XML 要素の既定の名前空間、XML ルート要素として使用されるクラスとその場所、およびアクセスで要求される資格情報を提供できます。 |
XmlSerializer()
XmlSerializer クラスの新しいインスタンスを初期化します。
protected:
XmlSerializer();
protected XmlSerializer ();
Protected Sub New ()
適用対象
XmlSerializer(Type)
指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。
public:
XmlSerializer(Type ^ type);
public XmlSerializer (Type type);
new System.Xml.Serialization.XmlSerializer : Type -> System.Xml.Serialization.XmlSerializer
Public Sub New (type As Type)
パラメーター
- type
- Type
XmlSerializer がシリアル化できるオブジェクトの型。
例
次の例では、という名前Widget
のオブジェクトをXmlSerializerシリアル化するオブジェクトを構築します。 この例では、メソッドを呼び出す前に、オブジェクトのさまざまなプロパティを Serialize 設定します。
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(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;
}
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
注釈
通常、アプリケーションでは、1 つの XML インスタンス ドキュメントに変換する XmlSerializer 複数のクラスを定義します。 ただし、XML ルート要素を XmlSerializer 表すクラスの型を認識する必要があるのは 1 つだけです。 すべての XmlSerializer 下位クラス インスタンスが自動的にシリアル化されます。 同様に、逆シリアル化には XML ルート要素の型のみが必要です。
こちらもご覧ください
- Serialize(TextWriter, Object)
- Deserialize(Stream)
- XmlAttributes
- XML シリアル化の概要
- 方法: XML ストリームの代替要素名を指定する
- 属性を使用した XML シリアル化の制御
- XML シリアル化の例
- XML Schema Definition Tool (Xsd.exe)
適用対象
XmlSerializer(XmlTypeMapping)
ある型を別の型にマップするオブジェクトを指定して、XmlSerializer クラスのインスタンスを初期化します。
public:
XmlSerializer(System::Xml::Serialization::XmlTypeMapping ^ xmlTypeMapping);
public XmlSerializer (System.Xml.Serialization.XmlTypeMapping xmlTypeMapping);
new System.Xml.Serialization.XmlSerializer : System.Xml.Serialization.XmlTypeMapping -> System.Xml.Serialization.XmlSerializer
Public Sub New (xmlTypeMapping As XmlTypeMapping)
パラメーター
- xmlTypeMapping
- XmlTypeMapping
1 つの型から別の型への割り当てを行う XmlTypeMapping。
例
次の例では、という名前 Group
のクラスをシリアル化します。 列挙体の GroupName
、 IgnoreThis
フィールド、およびメンバーの GroupType
シリアル化がオーバーライドされます。 CreateOverrideSerializer
メソッドでは、SoapAttributeOverridesオブジェクトが作成され、オーバーライドされたメンバーまたは列挙ごとに、SoapAttributes適切なプロパティ セットを使用してオブジェクトが作成され、オブジェクトにSoapAttributeOverrides追加されます。 XmlMappingオブジェクトはオブジェクトをSoapAttributeOverrides使用して作成され、そのXmlMappingオブジェクトは既定のシリアル化をXmlSerializerオーバーライドするオブジェクトを作成するために使用されます。
#using <System.Xml.dll>
#using <System.dll>
using namespace System;
using namespace System::IO;
using namespace System::Text;
using namespace System::Xml;
using namespace System::Xml::Serialization;
using namespace System::Xml::Schema;
ref class Car;
// SoapInclude allows Vehicle to accept Car type.
[SoapInclude(Car::typeid)]
public ref class Vehicle abstract
{
public:
String^ licenseNumber;
DateTime makeDate;
};
public ref class Car: public Vehicle{};
public enum class GroupType
{
// These enums can be overridden.
[SoapEnum("Small")]
A,
[SoapEnum("Large")]
B
};
public ref class Group
{
public:
[SoapAttributeAttribute(Namespace="http://www.cpandl.com")]
String^ GroupName;
[SoapAttributeAttribute(DataType="base64Binary")]
array<Byte>^GroupNumber;
[SoapAttributeAttribute(DataType="date",AttributeName="CreationDate")]
DateTime Today;
[SoapElement(DataType="nonNegativeInteger",ElementName="PosInt")]
String^ PostitiveInt;
// This is ignored when serialized unless it's overridden.
[SoapIgnore]
bool IgnoreThis;
GroupType Grouptype;
Vehicle^ MyVehicle;
// The SoapInclude allows the method to return a Car.
[SoapInclude(Car::typeid)]
Vehicle^ myCar( String^ licNumber )
{
Vehicle^ v;
if ( licNumber->Equals( "" ) )
{
v = gcnew Car;
v->licenseNumber = "!!!!!!";
}
else
{
v = gcnew Car;
v->licenseNumber = licNumber;
}
return v;
}
};
public ref class Run
{
public:
static void main()
{
Run^ test = gcnew Run;
test->SerializeOriginal( "SoapOriginal.xml" );
test->SerializeOverride( "SoapOverrides.xml" );
test->DeserializeOriginal( "SoapOriginal.xml" );
test->DeserializeOverride( "SoapOverrides.xml" );
}
void SerializeOriginal( String^ filename )
{
// Create an instance of the XmlSerializer class.
XmlTypeMapping^ myMapping = (gcnew SoapReflectionImporter)->ImportTypeMapping( Group::typeid );
XmlSerializer^ mySerializer = gcnew XmlSerializer( myMapping );
Group^ myGroup = MakeGroup();
// Writing the file requires a TextWriter.
XmlTextWriter^ writer = gcnew 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();
}
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 = gcnew 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 = gcnew Group;
// Set the object properties.
myGroup->GroupName = ".NET";
array<Byte>^hexByte = {Convert::ToByte( 100 ),Convert::ToByte( 50 )};
myGroup->GroupNumber = hexByte;
DateTime myDate = DateTime(2002,5,2);
myGroup->Today = myDate;
myGroup->PostitiveInt = "10000";
myGroup->IgnoreThis = true;
myGroup->Grouptype = GroupType::B;
Car^ thisCar = dynamic_cast<Car^>(myGroup->myCar( "1234566" ));
myGroup->MyVehicle = thisCar;
return myGroup;
}
public:
void DeserializeOriginal( String^ filename )
{
// Create an instance of the XmlSerializer class.
XmlTypeMapping^ myMapping = (gcnew SoapReflectionImporter)->ImportTypeMapping( Group::typeid );
XmlSerializer^ mySerializer = gcnew XmlSerializer( myMapping );
// Reading the file requires an XmlTextReader.
XmlTextReader^ reader = gcnew XmlTextReader( filename );
reader->ReadStartElement( "wrapper" );
// Deserialize and cast the object.
Group^ myGroup;
myGroup = dynamic_cast<Group^>(mySerializer->Deserialize( reader ));
reader->ReadEndElement();
reader->Close();
}
void DeserializeOverride( String^ filename )
{
// Create an instance of the XmlSerializer class.
XmlSerializer^ overRideSerializer = CreateOverrideSerializer();
// Reading the file requires an XmlTextReader.
XmlTextReader^ reader = gcnew XmlTextReader( filename );
reader->ReadStartElement( "wrapper" );
// Deserialize and cast the object.
Group^ myGroup;
myGroup = dynamic_cast<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();
}
XmlSerializer^ CreateOverrideSerializer()
{
SoapAttributeOverrides^ mySoapAttributeOverrides = gcnew SoapAttributeOverrides;
SoapAttributes^ soapAtts = gcnew SoapAttributes;
SoapElementAttribute^ mySoapElement = gcnew SoapElementAttribute;
mySoapElement->ElementName = "xxxx";
soapAtts->SoapElement = mySoapElement;
mySoapAttributeOverrides->Add( Group::typeid, "PostitiveInt", soapAtts );
// Override the IgnoreThis property.
SoapIgnoreAttribute^ myIgnore = gcnew SoapIgnoreAttribute;
soapAtts = gcnew SoapAttributes;
soapAtts->SoapIgnore = false;
mySoapAttributeOverrides->Add( Group::typeid, "IgnoreThis", soapAtts );
// Override the GroupType enumeration.
soapAtts = gcnew SoapAttributes;
SoapEnumAttribute^ xSoapEnum = gcnew SoapEnumAttribute;
xSoapEnum->Name = "Over1000";
soapAtts->GroupType::SoapEnum = xSoapEnum;
// Add the SoapAttributes to the
// mySoapAttributeOverridesrides object.
mySoapAttributeOverrides->Add( GroupType::typeid, "A", soapAtts );
// Create second enumeration and add it.
soapAtts = gcnew SoapAttributes;
xSoapEnum = gcnew SoapEnumAttribute;
xSoapEnum->Name = "ZeroTo1000";
soapAtts->GroupType::SoapEnum = xSoapEnum;
mySoapAttributeOverrides->Add( GroupType::typeid, "B", soapAtts );
// Override the Group type.
soapAtts = gcnew SoapAttributes;
SoapTypeAttribute^ soapType = gcnew SoapTypeAttribute;
soapType->TypeName = "Team";
soapAtts->SoapType = soapType;
mySoapAttributeOverrides->Add( Group::typeid, soapAtts );
// Create an XmlTypeMapping that is used to create an instance
// of the XmlSerializer. Then return the XmlSerializer object.
XmlTypeMapping^ myMapping = (gcnew SoapReflectionImporter( mySoapAttributeOverrides ))->ImportTypeMapping( Group::typeid );
XmlSerializer^ ser = gcnew XmlSerializer( myMapping );
return ser;
}
};
int main()
{
Run::main();
}
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;
}
}
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
注釈
このコンストラクターは、オブジェクトを SOAP メッセージにシリアル化するときに作成 XmlSerializer するために使用されます。 生成される SOAP メッセージを制御するには、名前空間にある特殊な属性 ("Soap" で始まる) を System.Xml.Serialization 使用します。
こちらもご覧ください
- XmlAttributes
- XML シリアル化の概要
- 方法: XML ストリームの代替要素名を指定する
- 属性を使用した XML シリアル化の制御
- XML シリアル化の例
- XML Schema Definition Tool (Xsd.exe)
適用対象
XmlSerializer(Type, String)
指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 すべての XML 要素の既定の名前空間を指定します。
public:
XmlSerializer(Type ^ type, System::String ^ defaultNamespace);
public XmlSerializer (Type type, string defaultNamespace);
public XmlSerializer (Type type, string? defaultNamespace);
new System.Xml.Serialization.XmlSerializer : Type * string -> System.Xml.Serialization.XmlSerializer
Public Sub New (type As Type, defaultNamespace As String)
パラメーター
- type
- Type
XmlSerializer がシリアル化できるオブジェクトの型。
- defaultNamespace
- String
すべての XML 要素で使用する既定の名前空間。
例
次の例では、という名前Widget
のオブジェクトをXmlSerializerシリアル化するオブジェクトを構築します。 この例では、メソッドを呼び出す前に、オブジェクトのさまざまなプロパティを Serialize 設定します。
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
(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.
}
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
こちらもご覧ください
- XmlAttributes
- XML シリアル化の概要
- 方法: XML ストリームの代替要素名を指定する
- 属性を使用した XML シリアル化の制御
- XML シリアル化の例
- XML Schema Definition Tool (Xsd.exe)
適用対象
XmlSerializer(Type, Type[])
指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 プロパティまたはフィールドが配列を返す場合、extraTypes
パラメーターには、その配列に挿入できるオブジェクトを指定します。
public:
XmlSerializer(Type ^ type, cli::array <Type ^> ^ extraTypes);
public XmlSerializer (Type type, Type[] extraTypes);
public XmlSerializer (Type type, Type[]? extraTypes);
new System.Xml.Serialization.XmlSerializer : Type * Type[] -> System.Xml.Serialization.XmlSerializer
Public Sub New (type As Type, extraTypes As Type())
パラメーター
- type
- Type
XmlSerializer がシリアル化できるオブジェクトの型。
例
次の例では、オブジェクトの配列を返すパブリック フィールドを含むクラスのインスタンスをシリアル化します。 コンストラクターのXmlSerializerパラメーターはextraTypes
、配列でシリアル化できるオブジェクトの型を指定します。
#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();
}
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);
}
}
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
' 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
' This defines one of the extra types to be included.
Public Class Address
Public City As String
Public Sub New()
End Sub
Public Sub New(city As String)
me.City = city
End Sub
End Class
' Another extra type to include.
Public Class Phone
Public PhoneNumber As String
Public Sub New()
End Sub
Public Sub New(phoneNumber As String)
me.PhoneNumber = phoneNumber
End Sub
End Class
' Another type, derived from Phone.
Public Class InternationalPhone
Inherits Phone
Public CountryCode As String
Public Sub New()
End Sub
Public Sub New(countryCode As String)
me.CountryCode = countryCode
End Sub
End Class
Public Class Run
Public Shared Sub Main()
Dim test As New Run()
test.SerializeObject("Teacher.xml")
test.DeserializeObject("Teacher.xml")
End Sub
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
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
End Class
注釈
既定では、パブリック プロパティまたはフィールドがオブジェクトまたはオブジェクトの配列を返す場合、オブジェクト型は自動的にシリアル化されます。 ただし、クラスに型 Objectの配列を返すフィールドまたはプロパティが含まれている場合は、任意のオブジェクトをその配列に挿入できます。 その場合は、配列に XmlSerializer 挿入されるすべての可能なオブジェクト型を想定するように指示する Object 必要があります。 これを行うには、パラメーターを extraTypes
使用して、シリアル化または逆シリアル化する追加のオブジェクト型を指定します。
パラメーターを extraTypes
使用して、基底クラスから派生した型を指定することもできます。 たとえば、名前が付いた Phone
基底クラスが存在し、そのクラスから派生したクラス InternationalPhone
があるとします。 このパラメーターを extraTypes
使用して、派生型も指定します。
こちらもご覧ください
- XmlAttributes
- XML シリアル化の概要
- 方法: XML ストリームの代替要素名を指定する
- 属性を使用した XML シリアル化の制御
- XML シリアル化の例
- XML Schema Definition Tool (Xsd.exe)
適用対象
XmlSerializer(Type, XmlAttributeOverrides)
指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 シリアル化される各オブジェクトはそれ自体がクラスのインスタンスを含むことができ、それをこのオーバーロードによって他のクラスでオーバーライドします。
public:
XmlSerializer(Type ^ type, System::Xml::Serialization::XmlAttributeOverrides ^ overrides);
public XmlSerializer (Type type, System.Xml.Serialization.XmlAttributeOverrides overrides);
public XmlSerializer (Type type, System.Xml.Serialization.XmlAttributeOverrides? overrides);
new System.Xml.Serialization.XmlSerializer : Type * System.Xml.Serialization.XmlAttributeOverrides -> System.Xml.Serialization.XmlSerializer
Public Sub New (type As Type, overrides As XmlAttributeOverrides)
パラメーター
- type
- Type
シリアル化するオブジェクトの型。
- overrides
- XmlAttributeOverrides
例
次の例では、DLL で定義されているクラスのインスタンスをシリアル化し、それを行うために、DLL で見つかったパブリック メンバーをオーバーライドします。
// 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();
}
// 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");
}
}
}
}
' Beginning of HighSchool.dll
Imports System.IO
Imports System.Xml
Imports System.Xml.Serialization
Imports HighSchool
Namespace HighSchool
Public Class Student
Public Name As String
Public ID As Integer
End Class
Public Class MyClass1
Public Students() As Student
End Class
End Namespace 'HighSchool
Namespace College
Public Class Graduate
Inherits HighSchool.Student
Public Sub New()
End Sub
Public University As String
End Class
Public Class Run
Public Shared Sub Main()
Dim test As New Run()
test.WriteOverriddenAttributes("College.xml")
test.ReadOverriddenAttributes("College.xml")
End Sub
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
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
End Class
End Namespace 'College
注釈
この overrides
パラメーターを使用して、フィールドとプロパティを XML でエンコードする方法を制御できます。 これらの設定は、オブジェクトに既に存在するすべての属性をオーバーライドします。 これは、ソース コードを変更できない場合や、同じクラスに複数のエンコードが必要な場合に便利です。
こちらもご覧ください
- XmlAttributeOverrides
- XmlAttributes
- XML シリアル化の概要
- 方法: XML ストリームの代替要素名を指定する
- 属性を使用した XML シリアル化の制御
- XML シリアル化の例
- XML Schema Definition Tool (Xsd.exe)
適用対象
XmlSerializer(Type, XmlRootAttribute)
指定した型のオブジェクトを XML ドキュメントにシリアル化したり、XML ドキュメントを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 また、XML ルート要素として使用するクラスを指定します。
public:
XmlSerializer(Type ^ type, System::Xml::Serialization::XmlRootAttribute ^ root);
public XmlSerializer (Type type, System.Xml.Serialization.XmlRootAttribute root);
public XmlSerializer (Type type, System.Xml.Serialization.XmlRootAttribute? root);
new System.Xml.Serialization.XmlSerializer : Type * System.Xml.Serialization.XmlRootAttribute -> System.Xml.Serialization.XmlSerializer
Public Sub New (type As Type, root As XmlRootAttribute)
パラメーター
- type
- Type
XmlSerializer がシリアル化できるオブジェクトの型。
- root
- XmlRootAttribute
XML ルート要素を表す XmlRootAttribute。
例
次の例では、XML ルート要素のさまざまなプロパティ (名前空間や要素名など) を含むオブジェクトを使用XmlRootAttributeするオブジェクトを構築XmlSerializerします。
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.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.
}
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
注釈
XML ドキュメントのルート要素は、他のすべての要素を囲みます。 既定では、パラメーターで type
指定されたオブジェクトはルート要素としてシリアル化されます。 ルート要素の XML 要素名などのプロパティは、オブジェクトから type
取得されます。 ただし、パラメーターを root
使用すると、既定のオブジェクトの情報を XmlRootAttribute置き換えることができます。オブジェクトを使用すると、別の名前空間や要素名などを設定できます。
こちらもご覧ください
- XmlAttributes
- XML シリアル化の概要
- 方法: XML ストリームの代替要素名を指定する
- 属性を使用した XML シリアル化の制御
- XML シリアル化の例
- XML Schema Definition Tool (Xsd.exe)
適用対象
XmlSerializer(Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String)
Object 型のオブジェクトを XML ドキュメント インスタンスにシリアル化したり、XML ドキュメント インスタンスを Object 型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 シリアル化される各オブジェクトはそれ自体がクラスのインスタンスを含むことができ、それをこのオーバーロードによって他のクラスでオーバーライドします。 このオーバーロードでは、すべての XML 要素の既定の名前空間、および XML ルート要素として使用するクラスも指定します。
public:
XmlSerializer(Type ^ type, System::Xml::Serialization::XmlAttributeOverrides ^ overrides, cli::array <Type ^> ^ extraTypes, System::Xml::Serialization::XmlRootAttribute ^ root, System::String ^ defaultNamespace);
public XmlSerializer (Type type, System.Xml.Serialization.XmlAttributeOverrides overrides, Type[] extraTypes, System.Xml.Serialization.XmlRootAttribute root, string defaultNamespace);
public XmlSerializer (Type type, System.Xml.Serialization.XmlAttributeOverrides? overrides, Type[]? extraTypes, System.Xml.Serialization.XmlRootAttribute? root, string? defaultNamespace);
new System.Xml.Serialization.XmlSerializer : Type * System.Xml.Serialization.XmlAttributeOverrides * Type[] * System.Xml.Serialization.XmlRootAttribute * string -> System.Xml.Serialization.XmlSerializer
Public Sub New (type As Type, overrides As XmlAttributeOverrides, extraTypes As Type(), root As XmlRootAttribute, defaultNamespace As String)
パラメーター
- type
- Type
XmlSerializer がシリアル化できるオブジェクトの型。
- overrides
- XmlAttributeOverrides
type
パラメーターで指定されたクラスの動作を拡張またはオーバーライドする XmlAttributeOverrides。
- root
- XmlRootAttribute
XML ルート要素プロパティを定義する XmlRootAttribute。
- defaultNamespace
- String
XML ドキュメント内のすべての XML 要素の既定の名前空間。
例
次の例では、DLL で定義されているクラスのインスタンスをシリアル化し、それを行うために、クラスで見つかったパブリック メンバーをオーバーライドします。 この例では、追加の型の配列、すべての XML 要素の既定の名前空間、および XML ルート要素情報を提供する使用するクラスも指定します。 この例では、先頭のコードが DLL という名前 HighSchool
にコンパイルされていることを前提としています。
// 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();
}
// 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);
}
}
}
}
'Beginning of the HighSchool.dll
Imports System.IO
Imports System.Xml
Imports System.Xml.Serialization
' Imports HighSchool
Namespace HighSchool
Public Class Student
Public Name As String
Public ID As Integer
End Class
Public Class ClassRoom
Public Students() As Student
End Class
End Namespace 'HighSchool
Namespace College
Public Class Graduate
Inherits HighSchool.Student
Public Sub New()
End Sub
' Add a new field named University.
Public University As String
' Use extra types to use this field.
Public Info() As Object
End Class
Public Class Address
Public City As String
End Class
Public Class Phone
Public Number As String
End Class
Public Class Run
Public Shared Sub Main()
Dim test As New Run()
test.WriteOverriddenAttributes("College.xml")
test.ReadOverriddenAttributes("College.xml")
End Sub
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
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
End Class
End Namespace 'College
注釈
この overrides
パラメーターを使用すると、基底クラスの動作を XmlSerializer 拡張またはオーバーライドするクラスをシリアル化するクラスを作成できます。 たとえば、DLL を指定すると、DLL に含まれるクラスを継承または拡張するクラスを作成できます。 このようなクラスをシリアル化するには、クラスの XmlAttributeOverrides インスタンスを作成するときに使用する XmlSerializer必要があります。 詳細については、「XmlAttributeOverrides」を参照してください。
既定では、パブリック プロパティまたはフィールドがオブジェクトまたはオブジェクトの配列を返す場合、オブジェクト型は自動的にシリアル化されます。 ただし、クラスに型 Objectの配列を返すフィールドまたはプロパティが含まれている場合は、任意のオブジェクトをその配列に挿入できます。 その場合は、配列に XmlSerializer 挿入されるすべての可能なオブジェクト型を想定するように指示する Object 必要があります。 これを行うには、パラメーターを extraTypes
使用して、シリアル化または逆シリアル化する追加のオブジェクト型を指定します。
XML ドキュメントのルート要素は、他のすべての要素を囲みます。 既定では、パラメーターで type
指定されたオブジェクトはルート要素としてシリアル化されます。 ルート要素の XML 要素名などのプロパティは、オブジェクトから type
取得されます。 ただし、パラメーターを root
使用すると、既定のオブジェクトの情報を XmlRootAttribute置き換えることができます。オブジェクトを使用すると、別の名前空間や要素名などを設定できます。
パラメーターを defaultName
使用して、によって生成されるすべての XML 要素の既定の名前空間を指定します XmlSerializer。
こちらもご覧ください
- XmlAttributeOverrides
- XmlRootAttribute
- XmlAttributes
- XML シリアル化の概要
- 方法: XML ストリームの代替要素名を指定する
- 属性を使用した XML シリアル化の制御
- XML シリアル化の例
- XML Schema Definition Tool (Xsd.exe)
適用対象
XmlSerializer(Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String, String)
Object 型のオブジェクトを XML ドキュメント インスタンスにシリアル化したり、XML ドキュメント インスタンスを Object 型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 シリアル化される各オブジェクトはそれ自体がクラスのインスタンスを含むことができ、それをこのオーバーロードによって他のクラスでオーバーライドします。 このオーバーロードでは、すべての XML 要素の既定の名前空間、および XML ルート要素として使用するクラスも指定します。
public:
XmlSerializer(Type ^ type, System::Xml::Serialization::XmlAttributeOverrides ^ overrides, cli::array <Type ^> ^ extraTypes, System::Xml::Serialization::XmlRootAttribute ^ root, System::String ^ defaultNamespace, System::String ^ location);
public XmlSerializer (Type type, System.Xml.Serialization.XmlAttributeOverrides? overrides, Type[]? extraTypes, System.Xml.Serialization.XmlRootAttribute? root, string? defaultNamespace, string? location);
public XmlSerializer (Type type, System.Xml.Serialization.XmlAttributeOverrides overrides, Type[] extraTypes, System.Xml.Serialization.XmlRootAttribute root, string defaultNamespace, string location);
new System.Xml.Serialization.XmlSerializer : Type * System.Xml.Serialization.XmlAttributeOverrides * Type[] * System.Xml.Serialization.XmlRootAttribute * string * string -> System.Xml.Serialization.XmlSerializer
Public Sub New (type As Type, overrides As XmlAttributeOverrides, extraTypes As Type(), root As XmlRootAttribute, defaultNamespace As String, location As String)
パラメーター
- type
- Type
XmlSerializer がシリアル化できるオブジェクトの型。
- overrides
- XmlAttributeOverrides
type
パラメーターで指定されたクラスの動作を拡張またはオーバーライドする XmlAttributeOverrides。
- root
- XmlRootAttribute
XML ルート要素プロパティを定義する XmlRootAttribute。
- defaultNamespace
- String
XML ドキュメント内のすべての XML 要素の既定の名前空間。
- location
- String
型の位置。
適用対象
XmlSerializer(Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String, String, Evidence)
注意事項
This method is obsolete and will be removed in a future release of the .NET Framework. Please use a XmlSerializer constructor overload which does not take an Evidence parameter. See http://go2.microsoft.com/fwlink/?LinkId=131738 for more information.
指定した型のオブジェクトを XML ドキュメント インスタンスにシリアル化したり、XML ドキュメント インスタンスを指定した型のオブジェクトに逆シリアル化したりできる、XmlSerializer クラスの新しいインスタンスを初期化します。 このオーバーロードでは、シリアル化操作または逆シリアル化操作で見つかる可能性がある他の型、すべての XML 要素の既定の名前空間、XML ルート要素として使用されるクラスとその場所、およびアクセスで要求される資格情報を提供できます。
public:
XmlSerializer(Type ^ type, System::Xml::Serialization::XmlAttributeOverrides ^ overrides, cli::array <Type ^> ^ extraTypes, System::Xml::Serialization::XmlRootAttribute ^ root, System::String ^ defaultNamespace, System::String ^ location, System::Security::Policy::Evidence ^ evidence);
public XmlSerializer (Type type, System.Xml.Serialization.XmlAttributeOverrides overrides, Type[] extraTypes, System.Xml.Serialization.XmlRootAttribute root, string defaultNamespace, string location, System.Security.Policy.Evidence evidence);
[System.Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use a XmlSerializer constructor overload which does not take an Evidence parameter. See http://go2.microsoft.com/fwlink/?LinkId=131738 for more information.")]
public XmlSerializer (Type type, System.Xml.Serialization.XmlAttributeOverrides overrides, Type[] extraTypes, System.Xml.Serialization.XmlRootAttribute root, string defaultNamespace, string location, System.Security.Policy.Evidence evidence);
new System.Xml.Serialization.XmlSerializer : Type * System.Xml.Serialization.XmlAttributeOverrides * Type[] * System.Xml.Serialization.XmlRootAttribute * string * string * System.Security.Policy.Evidence -> System.Xml.Serialization.XmlSerializer
[<System.Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use a XmlSerializer constructor overload which does not take an Evidence parameter. See http://go2.microsoft.com/fwlink/?LinkId=131738 for more information.")>]
new System.Xml.Serialization.XmlSerializer : Type * System.Xml.Serialization.XmlAttributeOverrides * Type[] * System.Xml.Serialization.XmlRootAttribute * string * string * System.Security.Policy.Evidence -> System.Xml.Serialization.XmlSerializer
Public Sub New (type As Type, overrides As XmlAttributeOverrides, extraTypes As Type(), root As XmlRootAttribute, defaultNamespace As String, location As String, evidence As Evidence)
パラメーター
- type
- Type
XmlSerializer がシリアル化できるオブジェクトの型。
- overrides
- XmlAttributeOverrides
type
パラメーターで指定されたクラスの動作を拡張またはオーバーライドする XmlAttributeOverrides。
- root
- XmlRootAttribute
XML ルート要素プロパティを定義する XmlRootAttribute。
- defaultNamespace
- String
XML ドキュメント内のすべての XML 要素の既定の名前空間。
- location
- String
型の位置。
- 属性
注釈
一時ディレクトリへのアクセスをより正確に制御でき、コードの挿入と悪用を防ぐことができます。 この方法を使用するには、場所を指定し、特定のユーザーにのみアクセス権を付与します。 管理者は、証拠とアクセス許可が一致する証拠リストを使用してポリシーを設定できます。