XMLシリアル化可能なオブジェクトの汎用リストをシリアル化します
型を指定せずに、シリアル化可能なオブジェクトの汎用リストをシリアル化できますか。
以下の壊れたコードの背後にある意図のようなもの：
List<ISerializable> serializableList = new List<ISerializable>();
XmlSerializer xmlSerializer = new XmlSerializer(serializableList.GetType());
serializableList.Add((ISerializable)PersonList);
using (StreamWriter streamWriter = System.IO.File.CreateText(fileName))
{
xmlSerializer.Serialize(streamWriter, serializableList);
}
編集：
詳細を知りたい人のために：このコードを実行しようとすると、XMLSerializer [...]行に次のエラーが表示されます。
インターフェイスSystem.Runtime.Serialization.ISerializableをシリアル化できません。
List<object>に変更すると、"There was an error generating the XML document."になります。 InnerExceptionの詳細は"{"The type System.Collections.Generic.List1[[Project1.Person, ConsoleFramework, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] may not be used in this context."}"です
人物オブジェクトは次のように定義されます。
[XmlRoot("Person")]
public class Person
{
string _firstName = String.Empty;
string _lastName = String.Empty;
private Person()
{
}
public Person(string lastName, string firstName)
{
_lastName = lastName;
_firstName = firstName;
}
[XmlAttribute(DataType = "string", AttributeName = "LastName")]
public string LastName
{
get { return _lastName; }
set { _lastName = value; }
}
[XmlAttribute(DataType = "string", AttributeName = "FirstName")]
public string FirstName
{
get { return _firstName; }
set { _firstName = value; }
}
}
PersonListはList<Person>です。
ただし、これはテスト用であるため、詳細があまりにも重要であるとは感じませんでした。重要なのは、1つ以上の異なるオブジェクトがあり、それらはすべてシリアル化可能であるということです。それらをすべて1つのファイルにシリアル化したい。それを行う最も簡単な方法は、それらを一般的なリストに入れ、リストを一度にシリアル化することだと思いました。しかし、これは機能しません。
List<IXmlSerializable>でも試しましたが、それは失敗します
System.Xml.Serialization.IXmlSerializable cannot be serialized because it does not have a parameterless constructor.
詳細がないので申し訳ありませんが、私はこれの初心者であり、どの詳細が必要かわかりません。より詳細な情報を求めている人が、どのような詳細情報が必要かを理解できるような方法で応答しようとしたり、考えられる方向を概説する基本的な回答があれば役立つでしょう。
また、ありがとうこれまでに得た2つの答えに-これらのアイデアが得られないまま読書にもっと多くの時間を費やすことができたでしょう。このサイトで人々がどれほど役立つかは驚くべきことです。
動的にバインドされたアイテムを含む一般的なList <>のソリューションがあります。
クラスPersonalListそれはルート要素です
[XmlRoot("PersonenListe")]
[XmlInclude(typeof(Person))] // include type class Person
public class PersonalList
{
[XmlArray("PersonenArray")]
[XmlArrayItem("PersonObjekt")]
public List<Person> Persons = new List<Person>();
[XmlElement("Listname")]
public string Listname { get; set; }
// Konstruktoren
public PersonalList() { }
public PersonalList(string name)
{
this.Listname = name;
}
public void AddPerson(Person person)
{
Persons.Add(person);
}
}
クラスPersonそれは単一のリスト要素です
[XmlType("Person")] // define Type
[XmlInclude(typeof(SpecialPerson)), XmlInclude(typeof(SuperPerson))]
// include type class SpecialPerson and class SuperPerson
public class Person
{
[XmlAttribute("PersID", DataType = "string")]
public string ID { get; set; }
[XmlElement("Name")]
public string Name { get; set; }
[XmlElement("City")]
public string City { get; set; }
[XmlElement("Age")]
public int Age { get; set; }
// Konstruktoren
public Person() { }
public Person(string name, string city, int age, string id)
{
this.Name = name;
this.City = city;
this.Age = age;
this.ID = id;
}
}
クラスSpecialPersonはPersonを継承します
[XmlType("SpecialPerson")] // define Type
public class SpecialPerson : Person
{
[XmlElement("SpecialInterests")]
public string Interests { get; set; }
public SpecialPerson() { }
public SpecialPerson(string name, string city, int age, string id, string interests)
{
this.Name = name;
this.City = city;
this.Age = age;
this.ID = id;
this.Interests = interests;
}
}
クラスSuperPersonはPersonを継承します
[XmlType("SuperPerson")] // define Type
public class SuperPerson : Person
{
[XmlArray("Skills")]
[XmlArrayItem("Skill")]
public List<String> Skills { get; set; }
[XmlElement("Alias")]
public string Alias { get; set; }
public SuperPerson()
{
Skills = new List<String>();
}
public SuperPerson(string name, string city, int age, string id, string[] skills, string alias)
{
Skills = new List<String>();
this.Name = name;
this.City = city;
this.Age = age;
this.ID = id;
foreach (string item in skills)
{
this.Skills.Add(item);
}
this.Alias = alias;
}
}
そしてメインのテストソース
static void Main(string[] args)
{
PersonalList personen = new PersonalList();
personen.Listname = "Friends";
// normal person
Person normPerson = new Person();
normPerson.ID = "0";
normPerson.Name = "Max Man";
normPerson.City = "Capitol City";
normPerson.Age = 33;
// special person
SpecialPerson specPerson = new SpecialPerson();
specPerson.ID = "1";
specPerson.Name = "Albert Einstein";
specPerson.City = "Ulm";
specPerson.Age = 36;
specPerson.Interests = "Physics";
// super person
SuperPerson supPerson = new SuperPerson();
supPerson.ID = "2";
supPerson.Name = "Superman";
supPerson.Alias = "Clark Kent";
supPerson.City = "Metropolis";
supPerson.Age = int.MaxValue;
supPerson.Skills.Add("fly");
supPerson.Skills.Add("strong");
// Add Persons
personen.AddPerson(normPerson);
personen.AddPerson(specPerson);
personen.AddPerson(supPerson);
// Serialize
Type[] personTypes = { typeof(Person), typeof(SpecialPerson), typeof(SuperPerson) };
XmlSerializer serializer = new XmlSerializer(typeof(PersonalList), personTypes);
FileStream fs = new FileStream("Personenliste.xml", FileMode.Create);
serializer.Serialize(fs, personen);
fs.Close();
personen = null;
// Deserialize
fs = new FileStream("Personenliste.xml", FileMode.Open);
personen = (PersonalList)serializer.Deserialize(fs);
serializer.Serialize(Console.Out, personen);
Console.ReadLine();
}
重要なのは、異なるタイプの定義と組み込みです。
XMLシリアル化の概要 を参照してください：
シリアル化できるアイテム
次の項目は、XmlSerializerクラスを使用してシリアル化できます。
- パブリッククラスのパブリックな読み取り/書き込みプロパティとフィールド
ICollectionまたはIEnumerableを実装するクラスXmlElementオブジェクトXmlNodeオブジェクトDataSetオブジェクト
特に、ISerializableまたは[Serializable]属性は重要ではありません。
問題が何であるかを説明したので（「機能しない」は問題の説明ではありません）、推測の代わりに実際の問題の答えを得ることができます。
型のコレクションをシリアル化するが、実際には派生型のインスタンスのコレクションをシリアル化する場合、実際にシリアル化する型をシリアライザーに知らせる必要があります。これは、objectのコレクションにも当てはまります。
XmlSerializer（Type、Type []） コンストラクターを使用して、可能なタイプのリストを提供する必要があります。
予想されるタイプを指定せずにオブジェクトのコレクションをシリアル化することはできません。期待されるタイプのリストをXmlSerializer（extraTypesパラメーター）のコンストラクターに渡す必要があります。
List<object> list = new List<object>();
list.Add(new Foo());
list.Add(new Bar());
XmlSerializer xs = new XmlSerializer(typeof(object), new Type[] {typeof(Foo), typeof(Bar)});
using (StreamWriter streamWriter = System.IO.File.CreateText(fileName))
{
xs.Serialize(streamWriter, list);
}
リストのすべてのオブジェクトが同じクラスを継承する場合、XmlInclude属性を使用して、期待されるタイプを指定することもできます。
[XmlInclude(typeof(Foo)), XmlInclude(typeof(Bar))]
public class MyBaseClass
{
}
次のような一般的な引数を持つメソッドを使用するのが最善だと思います：
public static void SerializeToXml<T>(T obj, string fileName)
{
using (var fileStream = new FileStream(fileName, FileMode.Create))
{
var ser = new XmlSerializer(typeof(T));
ser.Serialize(fileStream, obj);
}
}
public static T DeserializeFromXml<T>(string xml)
{
T result;
var ser = new XmlSerializer(typeof(T));
using (var tr = new StringReader(xml))
{
result = (T)ser.Deserialize(tr);
}
return result;
}
ドレアスのアプローチは大丈夫だと思う。ただし、これに代わる方法は、静的ヘルパーメソッドをいくつか用意し、各メソッドにIXmlSerializableを実装することです（例：XmlWriter拡張メソッドと、それを読み戻すXmlReaderメソッド）。
public static void SaveXmlSerialiableElement<T>(this XmlWriter writer, String elementName, T element) where T : IXmlSerializable
{
writer.WriteStartElement(elementName);
writer.WriteAttributeString("TYPE", element.GetType().AssemblyQualifiedName);
element.WriteXml(writer);
writer.WriteEndElement();
}
public static T ReadXmlSerializableElement<T>(this XmlReader reader, String elementName) where T : IXmlSerializable
{
reader.ReadToElement(elementName);
Type elementType = Type.GetType(reader.GetAttribute("TYPE"));
T element = (T)Activator.CreateInstance(elementType);
element.ReadXml(reader);
return element;
}
XmlSerializerクラスを直接使用する場合、新しいXmlSerializerを定期的に構築する際にパフォーマンスが大幅に低下する可能性があるため、可能であれば、事前にシリアル化アセンブリを作成してください。
コレクションには、次のようなものが必要です。
public static void SaveXmlSerialiazbleCollection<T>(this XmlWriter writer, String collectionName, String elementName, IEnumerable<T> items) where T : IXmlSerializable
{
writer.WriteStartElement(collectionName);
foreach (T item in items)
{
writer.WriteStartElement(elementName);
writer.WriteAttributeString("TYPE", item.GetType().AssemblyQualifiedName);
item.WriteXml(writer);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
私が見つけた最も簡単な方法.. System.Xml.Serialization.XmlArray属性を適用します。
[System.Xml.Serialization.XmlArray] //This is the part that makes it work
List<object> serializableList = new List<object>();
XmlSerializer xmlSerializer = new XmlSerializer(serializableList.GetType());
serializableList.Add(PersonList);
using (StreamWriter streamWriter = System.IO.File.CreateText(fileName))
{
xmlSerializer.Serialize(streamWriter, serializableList);
}
シリアライザーは、配列であることを認識し、リストのアイテムを子ノードとしてシリアル化します。
以下は私のプロジェクトのUtilクラスです：
namespace Utils
{
public static class SerializeUtil
{
public static void SerializeToFormatter<F>(object obj, string path) where F : IFormatter, new()
{
if (obj == null)
{
throw new NullReferenceException("obj Cannot be Null.");
}
if (obj.GetType().IsSerializable == false)
{
// throw new
}
IFormatter f = new F();
SerializeToFormatter(obj, path, f);
}
public static T DeserializeFromFormatter<T, F>(string path) where F : IFormatter, new()
{
T t;
IFormatter f = new F();
using (FileStream fs = File.OpenRead(path))
{
t = (T)f.Deserialize(fs);
}
return t;
}
public static void SerializeToXML<T>(string path, object obj)
{
XmlSerializer xs = new XmlSerializer(typeof(T));
using (FileStream fs = File.Create(path))
{
xs.Serialize(fs, obj);
}
}
public static T DeserializeFromXML<T>(string path)
{
XmlSerializer xs = new XmlSerializer(typeof(T));
using (FileStream fs = File.OpenRead(path))
{
return (T)xs.Deserialize(fs);
}
}
public static T DeserializeFromXml<T>(string xml)
{
T result;
var ser = new XmlSerializer(typeof(T));
using (var tr = new StringReader(xml))
{
result = (T)ser.Deserialize(tr);
}
return result;
}
private static void SerializeToFormatter(object obj, string path, IFormatter formatter)
{
using (FileStream fs = File.Create(path))
{
formatter.Serialize(fs, obj);
}
}
}
}
XML出力要件を変更できる場合は、常にバイナリシリアル化を使用できます。これは、異種のオブジェクトリストの操作に適しています。以下に例を示します。
private void SerializeList(List<Object> Targets, string TargetPath)
{
IFormatter Formatter = new BinaryFormatter();
using (FileStream OutputStream = System.IO.File.Create(TargetPath))
{
try
{
Formatter.Serialize(OutputStream, Targets);
} catch (SerializationException ex) {
//(Likely Failed to Mark Type as Serializable)
//...
}
}
そのまま使用：
[Serializable]
public class Animal
{
public string Home { get; set; }
}
[Serializable]
public class Person
{
public string Name { get; set; }
}
public void ExampleUsage() {
List<Object> SerializeMeBaby = new List<Object> {
new Animal { Home = "London, UK" },
new Person { Name = "Skittles" }
};
string TargetPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"Test1.dat");
SerializeList(SerializeMeBaby, TargetPath);
}
knowTypeListパラメーター DataContractSerializerでいくつかの既知のタイプをシリアル化します。
private static void WriteObject(
string fileName, IEnumerable<Vehichle> reflectedInstances, List<Type> knownTypeList)
{
using (FileStream writer = new FileStream(fileName, FileMode.Append))
{
foreach (var item in reflectedInstances)
{
var serializer = new DataContractSerializer(typeof(Vehichle), knownTypeList);
serializer.WriteObject(writer, item);
}
}
}