XML Serialize 可序列化对象的通用列表答案

【问题标题】：XML Serialize generic list of serializable objectsXML Serialize 可序列化对象的通用列表
【发布时间】：2010-11-15 19:29:52
【问题描述】：

我可以序列化一个可序列化对象的通用列表而不必指定它们的类型吗？

类似于以下损坏代码背后的意图：

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."}"

person对象定义如下：

[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> 。

这只是为了测试，所以不觉得细节太重要。关键是我有一个或多个不同的对象，所有这些对象都是可序列化的。我想将它们全部序列化到一个文件中。我认为最简单的方法是将它们放在一个通用列表中并一次性序列化该列表。但这不起作用。

我也尝试了List<IXmlSerializable>，但失败了

System.Xml.Serialization.IXmlSerializable cannot be serialized because it does not have a parameterless constructor.

抱歉缺少细节，但我是这方面的初学者，不知道需要什么细节。如果询问更多细节的人试图以一种让我了解需要哪些细节的方式做出回应，或者提供概述可能方向的基本答案，那将会很有帮助。

另外感谢到目前为止我得到的两个答案 - 如果没有得到这些想法，我本可以花更多时间阅读。令人惊讶的是，人们在这个网站上乐于助人。

【问题讨论】：

我试过了，没用，我不知道怎么让它工作。我尝试将其更改为 List
它以什么方式“不起作用”？如果您需要答案，请提供详细信息。
您遇到了什么错误？是所有对象都实现了ISerializable 还是只有[Serializable] 属性？
John：上面的例子（当适用于 List
无参数构造函数错误，因为您尝试序列化的类没有不带参数的构造。在每个类上定义一个私有的 (){}，这样就会消失。

标签： c# list generics xml-serialization

【解决方案1】：

我认为最好使用带有泛型参数的方法，如下所示：

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;
}

【讨论】：

也许可以，但这仍然不能满足我的要求 - 序列化对象列表，可能是不同类型的对象。我希望能够将一堆我想保存到列表中的对象添加到列表中，然后一次性序列化整个列表（并序列化到一个文件中）。
paradisonoir，它们的构造会为给定类型（以及所有需要反序列化的引用类型）创建临时序列化程序集。如果您有一个需要序列化的大型对象 graoh 或者只是大量对象并且您反复调用 XmlSerializer 那么它可能会很慢。我们发现序列化和反序列化某些设置需要 10-13 秒，而这些设置几乎是通过预先构建这些序列化程序集而立即完成的。
@Fred XmlSerializer(Type) 构造函数创建一个临时程序集来处理该类型的序列化并将其添加到 AppDomain，但如果您为同一类型再次调用它，它不会重复使用相同的临时程序集，它会创建另一个。由于程序集一旦加载就无法从 AppDomain 中删除，因此每次调用构造函数时，您的内存占用量都会略有增加。
在像我每天工作的应用程序中，如果每个新的临时程序集代表 1kb，我们每天将泄漏 200 GB。通过仔细管理类型缓存中的 XmlSerializer，我们将同一组序列化器保留在内存中，总成本约为 1 兆字节的缓存。
@RexM - 我知道这是一篇旧帖子，所以事情可能已经改变，但我认为XmlSerializer(Type) 重载是使用构造函数的安全方法之一，因为它确实重用了缓存的程序集？（另一个是公开的XmlSerializer(Type type, string defaultNamespace)）support.microsoft.com/kb/886385/en-us

【解决方案2】：

我认为 Dreas 的方法还可以。然而，另一种方法是使用一些静态辅助方法并在每个方法上实现 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();
}

【讨论】：

这看起来很有趣，但我不确定如何准确使用它。我会试着玩一下，看看能不能让它工作。
好的，首先集合中的所有对象都需要被强类型化为相同的基类型。对象需要实现 IXmlSerializable（不太难）。对于一个集合，例如List 然后你会调用类似的东西： XmlWriter.SaveXmlSerializableCollection("item", this.collectionOfTs)
顺便说一句，你也需要反序列化它们吗？如果没有，我可能可以为你提供一个更完整的例子......
我可能会反序列化，但这已经相当不错了。我会尝试把你已经给我的东西付诸实践。非常感谢。

【解决方案3】：

见Introducing XML Serialization:

可以序列化的项目

以下项目可以使用 XmlSerializer 进行序列化类：

公共类的公共读/写属性和字段

实现 ICollection 或 IEnumerable 的类

XmlElement 对象

XmlNode 对象

DataSet 对象

尤其是ISerializable 或[Serializable] 属性并不重要。

既然您已经告诉我们您的问题是什么（“它不起作用”不是问题陈述），您可以得到实际问题的答案，而不是猜测。

当您序列化一个类型的集合，但实际上将序列化一个派生类型的实例集合时，您需要让序列化程序知道您将实际序列化哪些类型。 object 的集合也是如此。

您需要使用XmlSerializer(Type,Type[]) 构造函数来给出可能类型的列表。

【讨论】：

msdn.microsoft.com/en-us/library/182eeyhh%28VS.85%29.aspx - 链接被破坏了，谢谢你，我了解更多...很多要阅读。
也感谢关于如何提问的建议，非常感谢。
+1。是的，它们对于 XML 无关紧要，但如果他想使用其他类型的序列化，它们会的。此外，由于他正在转换为 ISerializable，因此检查不同类型是否实现了该接口似乎是一个非常基本的问题。我希望这不是对我的评论的挖苦，我认为这有助于澄清其中的一些细节。
我只是说调用一个可序列化的对象和用 XML 序列化它是有区别的。我并没有把它看得太个人或太敏感。实际上，我对您的回答投了赞成票，因为它提出了一些关于在 XML 中序列化从未提及的优点。不过，对于 XML，它们可能不是必需，但它通常是一种很好的做法，这样您就可以轻松地支持其他序列化。
@Erich：我不同意。各种序列化技术差别太大。支持那些你不会使用的人是没有意义的。考虑一下：您是否打算测试您不使用的那些？在我看来，如果你没有测试它，那么它就行不通。为什么要编写你知道你不会测试的代码？

【解决方案4】：

如果可以更改 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);
}

【讨论】：

很好的例子。这更像是我的想法——许多不同的对象，我想将它们放入一个文件中。虽然我更喜欢 XML 而不是二进制，但我会试试这个。

【解决方案5】：

如果不指定预期类型，您将无法序列化对象集合。您必须将预期类型列表传递给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
{
}

【讨论】：

嗯，这看起来很有趣。我假设它仍然不会反序列化？
它将反序列化。实际上，在序列化过程中，一个额外的属性xsi:type 被写在代表对象的元素上。这允许 XmlSerializer 知道对象的实际类型
+1 很好的答案，据我所知，唯一能回答这个问题的。根据我自己的测试，您传递给 XmlSerializer ctor 的第一种类型应该是 List
如果你不知道从基类派生的所有类型，你会怎么做？例如，我正在编写一个插件框架，它有一个基类，将由第三方扩展。
@Dasiths，你能在运行时发现类型吗？如果可以，请尝试使用XmlAttributeOverrides 动态添加类型。

【解决方案6】：

下面是我项目中的一个 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);
            }
        }
    }
}

【讨论】：

IFormatter 的使用作为 XML 序列化问题的答案令人困惑。另外，你应该抛出ArgumentNullExeption，而不是NullReferenceException。你永远不应该抛出NullReferenceException。

【解决方案7】：

我有一个具有动态绑定项的通用 List 的解决方案。

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

重要的是不同类型的定义和包括。

【讨论】：

【解决方案8】：

knowTypeList parameter 让 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);
            }
        }
    }

【讨论】：

【解决方案9】：

我发现的最简单的方法。将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);
}

序列化程序将把它作为一个数组并将列表的项序列化为子节点。

【讨论】：

【解决方案10】：

让Serialize和Deserialize成为C#中的无名对象列表：

// create a list of Shapes to serialize.
List<Shape> listOfShapes = new()
{
    new Circle { Colour = "Red", Radius = 2.5 },
    new Rectangle { Colour = "Blue", Height = 20.0, Width = 10.0 },
    new Circle { Colour = "Green", Radius = 8.0 },
    new Circle { Colour = "Purple", Radius = 12.3 },
    new Rectangle { Colour = "Blue", Height = 45.0, Width = 18.0 }
};
    
string filepath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "Testfile.xml");
    
//Serialize 
List<Type> types = new();
foreach(Shape s in listOfShapes)
{
   types.Add(s.GetType());
}
XmlSerializer serializerXml = new XmlSerializer(listOfShapes.GetType(),types.ToArray());
FileStream fsxml = File.Create(filepath);
serializerXml.Serialize(fsxml, listOfShapes);
fsxml.Close();
    
//Deserialize.
FileStream fsxmlr= File.Open(filepath, FileMode.Open);
List<Shape> loadedShapesXml = serializerXml.Deserialize(fsxmlr) as List<Shape>;
foreach (Shape item in loadedShapesXml)
{
    WriteLine("{0} is {1} and has an area of {2:N2}",
    item.GetType().Name, item.Colour, item.Area);
}
fsxmlr.Close();

【讨论】：