继上一个问题之后，我一直致力于让我的对象模型序列化为 XML。但是我现在遇到了一个问题（平息惊喜！）。
我遇到的问题是我有一个集合，它是抽象基类类型，由具体派生类型填充。
我认为只需将 XML 属性添加到所有涉及的类就可以了，一切都会很好。可悲的是，事实并非如此！
所以我在谷歌上做了一些挖掘，现在我明白为什么它不起作用了。事实上，它XmlSerializer正在做一些巧妙的反射，以便将对象序列化到 XML 或从 XML 序列化，并且由于它基于抽象类型，它无法弄清楚它到底在与什么对话。美好的。
我确实在 CodeProject 上遇到过这个页面，看起来它可能很有帮助（尚未完全阅读/使用），但我想我也想把这个问题带到 StackOverflow 表中，看看你是否有任何整洁的黑客/技巧，以便以最快/最轻的方式启动和运行。
我还应该补充的一件事是我不想走这XmlInclude条路。与它的耦合太多了，而且系统的这个领域正在大力开发，所以这将是一个真正的维护头痛！
好的，所以我终于到了那里（诚然，这里有很多帮助！）。
所以总结一下：
我创建了一个泛型类，在其中您将泛型类型指定为您将使用的抽象类型。这使类能够在抽象类型和具体类型之间“转换”，因为我们可以对转换进行硬编码（即，我们可以获得比 XmlSerializer 更多的信息）。
然后我实现了IXmlSerializable接口，这非常简单，但是在序列化时，我们需要确保将具体类的类型写入 XML，以便在反序列化时将其转换回。同样重要的是要注意它必须是完全限定的，因为这两个类所在的程序集可能不同。当然，这里需要进行一些类型检查和一些事情。
由于 XmlSerializer 无法转换，我们需要提供代码来执行此操作，因此隐式运算符随后被重载（我什至不知道您可以这样做！）。
AbstractXmlSerializer 的代码是这样的：
using System;
using System.Collections.Generic;
using System.Text;
using System.Xml.Serialization;
namespace Utility.Xml
{
public class AbstractXmlSerializer<AbstractType> : IXmlSerializable
{
// Override the Implicit Conversions Since the XmlSerializer
// Casts to/from the required types implicitly.
public static implicit operator AbstractType(AbstractXmlSerializer<AbstractType> o)
{
return o.Data;
}
public static implicit operator AbstractXmlSerializer<AbstractType>(AbstractType o)
{
return o == null ? null : new AbstractXmlSerializer<AbstractType>(o);
}
private AbstractType _data;
/// <summary>
/// [Concrete] Data to be stored/is stored as XML.
/// </summary>
public AbstractType Data
{
get { return _data; }
set { _data = value; }
}
/// <summary>
/// **DO NOT USE** This is only added to enable XML Serialization.
/// </summary>
/// <remarks>DO NOT USE THIS CONSTRUCTOR</remarks>
public AbstractXmlSerializer()
{
// Default Ctor (Required for Xml Serialization - DO NOT USE)
}
/// <summary>
/// Initialises the Serializer to work with the given data.
/// </summary>
/// <param name="data">Concrete Object of the AbstractType Specified.</param>
public AbstractXmlSerializer(AbstractType data)
{
_data = data;
}
#region IXmlSerializable Members
public System.Xml.Schema.XmlSchema GetSchema()
{
return null; // this is fine as schema is unknown.
}
public void ReadXml(System.Xml.XmlReader reader)
{
// Cast the Data back from the Abstract Type.
string typeAttrib = reader.GetAttribute("type");
// Ensure the Type was Specified
if (typeAttrib == null)
throw new ArgumentNullException("Unable to Read Xml Data for Abstract Type '" + typeof(AbstractType).Name +
"' because no 'type' attribute was specified in the XML.");
Type type = Type.GetType(typeAttrib);
// Check the Type is Found.
if (type == null)
throw new InvalidCastException("Unable to Read Xml Data for Abstract Type '" + typeof(AbstractType).Name +
"' because the type specified in the XML was not found.");
// Check the Type is a Subclass of the AbstractType.
if (!type.IsSubclassOf(typeof(AbstractType)))
throw new InvalidCastException("Unable to Read Xml Data for Abstract Type '" + typeof(AbstractType).Name +
"' because the Type specified in the XML differs ('" + type.Name + "').");
// Read the Data, Deserializing based on the (now known) concrete type.
reader.ReadStartElement();
this.Data = (AbstractType)new
XmlSerializer(type).Deserialize(reader);
reader.ReadEndElement();
}
public void WriteXml(System.Xml.XmlWriter writer)
{
// Write the Type Name to the XML Element as an Attrib and Serialize
Type type = _data.GetType();
// BugFix: Assembly must be FQN since Types can/are external to current.
writer.WriteAttributeString("type", type.AssemblyQualifiedName);
new XmlSerializer(type).Serialize(writer, _data);
}
#endregion
}
}
那么，从那里，我们如何告诉 XmlSerializer 使用我们的序列化程序而不是默认的？我们必须在 Xml attributes 类型属性中传递我们的类型，例如：
[XmlRoot("ClassWithAbstractCollection")]
public class ClassWithAbstractCollection
{
private List<AbstractType> _list;
[XmlArray("ListItems")]
[XmlArrayItem("ListItem", Type = typeof(AbstractXmlSerializer<AbstractType>))]
public List<AbstractType> List
{
get { return _list; }
set { _list = value; }
}
private AbstractType _prop;
[XmlElement("MyProperty", Type=typeof(AbstractXmlSerializer<AbstractType>))]
public AbstractType MyProperty
{
get { return _prop; }
set { _prop = value; }
}
public ClassWithAbstractCollection()
{
_list = new List<AbstractType>();
}
}
在这里你可以看到，我们有一个集合和一个被暴露的属性，我们需要做的就是将类型命名参数添加到 Xml 声明中，很简单！:D
注意：如果您使用此代码，我将非常感谢您的支持。这也将有助于推动更多的人加入社区 :)
现在，但不确定如何处理这里的答案，因为他们都有自己的优点和缺点。我会升级那些我觉得有用的东西（对那些没有用的人没有冒犯），一旦我有代表就关闭它:)
有趣的问题和解决的乐趣！:)
需要注意的一点是，在 XmlSerialiser 构造函数中，您可以传递序列化器可能难以解析的类型数组。我不得不多次使用它，其中需要序列化一个集合或一组复杂的数据结构，并且这些类型存在于不同的程序集中等。
带有 extraTypes 参数的 XmlSerialiser 构造函数
编辑：我要补充一点，这种方法优于 XmlInclude 属性等，您可以找出一种在运行时发现和编译可能的具体类型列表并将它们填充的方法。
严肃地说，POCO 的可扩展框架永远不会可靠地序列化为 XML。我这样说是因为我可以保证有人会来，扩展你的课程，然后把它搞砸。
您应该考虑使用 XAML 来序列化您的对象图。它旨在做到这一点，而 XML 序列化不是。
Xaml 序列化器和反序列化器可以毫无问题地处理泛型、基类和接口的集合（只要集合本身实现IList或IDictionary）。有一些注意事项，例如用 标记您的只读集合属性DesignerSerializationAttribute，但是重新编写代码以处理这些极端情况并不难。
只是对此的快速更新，我没有忘记！
只是做更多的研究，看起来我是赢家，只需要对代码进行排序。
到目前为止，我有以下内容：
通过创建一个代理类作为序列化程序的中间人，这种行为似乎可以被覆盖（代码挂起）。这将基本上确定派生类的类型，然后正常序列化。然后，此代理类将该 XML 备份到主序列化程序的行中。
关注此空间！^_^
这当然是您的问题的解决方案，但还有另一个问题，它在某种程度上破坏了您使用“可移植”XML 格式的意图。当您决定在下一个版本的程序中更改类并且您需要支持两种序列化格式——新的和旧的（因为您的客户仍然使用他们的旧文件/数据库，或者他们连接到您的服务器使用旧版本的产品）。但是你不能再使用这个序列化器了，因为你用过
type.AssemblyQualifiedName
看起来像
TopNamespace.SubNameSpace.ContainingClass+NestedClass, MyAssembly, Version=1.3.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089
那是包含您的程序集属性和版本...
现在，如果您尝试更改您的程序集版本，或者您决定对其进行签名，则此反序列化将不起作用...
我做过类似的事情。我通常做的是确保所有 XML 序列化属性都在具体类上，并且只让该类上的属性调用基类（如果需要）以检索在序列化程序调用时将被反序列化的信息那些属性。它需要更多的编码工作，但它确实比试图强制序列化程序做正确的事情要好得多。
更好的是，使用符号：
[XmlRoot]
public class MyClass {
public abstract class MyAbstract {}
public class MyInherited : MyAbstract {}
[XmlArray(), XmlArrayItem(typeof(MyInherited))]
public MyAbstract[] Items {get; set; }
}