如何序列化其类相互引用的类层次结构，但避免 XmlInclude？

我有一个类的层次结构，我想使用XmlSerializer类及其相关属性。有一个基本抽象类，然后是相当多的派生类（在下面的代码中，我已将派生类的数量减少到五个，但实际代码中还有更多）。这些类形成一个层次结构，并且经常包含对层次结构中类的实例的引用。

public abstract class BaseType 
{
    // Only classes in my assembly can derive from this class
    internal BaseType() { }   
}

public sealed class TType : BaseType
{
    [XmlText]
    public string Name;
}

public sealed class PType : BaseType
{
    [XmlElement("t", typeof(TType)]
    [XmlElement("p", typeof(PType)]
    [XmlElement("a", typeof(AType)]
    [XmlElement("s", typeof(SType)]
    [XmlElement("u", typeof(UType)]
    public BaseType Child;
}

public sealed class SType : BaseType
{
    [XmlElement("t", typeof(TType)]
    [XmlElement("p", typeof(PType)]
    [XmlElement("s", typeof(SType)]
    [XmlElement("a", typeof(AType)]
    [XmlElement("u", typeof(UType)]
    public BaseType [] Items;
    public string [] ItemNames;
}

public sealed class AType : BaseType
{
    [XmlElement("t", typeof(TType)]
    [XmlElement("p", typeof(PType)]
    [XmlElement("s", typeof(SType)]
    [XmlElement("a", typeof(AType)]
    [XmlElement("u", typeof(UType)]
    public BaseType Item;
    public int Length;
}

public sealed class UType : BaseType
{
    [XmlElement("t", typeof(TType)]
    [XmlElement("p", typeof(PType)]
    [XmlElement("s", typeof(SType)]
    [XmlElement("a", typeof(AType)]
    [XmlElement("u", typeof(UType)]
    public BaseType [] Alts;
    public string [] AltNames;
}

最后，一个容器可以容纳所有这些并喂给XmlSerializer:

[XmlRoot("items")]
public class ItemCollection
{
    [XmlElement("t", typeof(TType)]
    [XmlElement("p", typeof(PType)]
    [XmlElement("s", typeof(SType)]
    [XmlElement("a", typeof(AType)]
    [XmlElement("u", typeof(UType)] 
    public BaseType [] Items;
}

正如您所看到的，我的代码中有相当多的重复。在某些时候，可能会引入一个新的派生类，并且所有使用 BaseType 引用的地方都必须使用新的派生类重新访问。XmlElement属性。这既乏味又容易出错。我想表达一个事实BaseType如果元素名称为“t”，则可以反序列化为 TType；如果元素名称为“p”，则可以反序列化为 PType，等等，仅一次。

我知道XmlIncludeAttribute但它介绍了xsi:type“金主”不满意的属性。有什么方法可以分解出 XML 元素名称和 CLR 类型之间的映射知识吗？

解决方案可以做出的一个假设是定义派生类的程序集已知BaseType。这意味着我们不必考虑将新类添加到外部程序集中。

经过一段时间的摆弄后，我想出了一个解决方案，并在这里发布以帮助处于相同情况的其他人。

首先，找到类型层次结构中的所有类型。然后编写一个函数来构建XmlElements包含所有这些类型的实例：

XmlAttributes CreateXmlAttributesForHierarchyTypes()
{
    return XmlAttributes
    {
        XmlElements = 
        {
            new XmlElementAttribute("t", typeof (TType)),
            new XmlElementAttribute("p", typeof (PType)),
            new XmlElementAttribute("s", typeof (SType)),
            new XmlElementAttribute("a", typeof (AType)),
            new XmlElementAttribute("u", typeof (UType)),
        }
    };
}

现在找到具有您希望序列化的上述类型之一的字段的所有类型。您可以通过反映程序集中的所有类来做到这一点，但就我而言，我碰巧知道只有少数类具有此要求：

Type [] typesToOverride = new Type[] 
{
    typeof(PType),
    typeof(SType),
    typeof(AType),
    typeof(UType),
    typeof(ItemCollection),
};

我们现在继续创建一个实例XmlAttributeOverrides指定了hierarchyTypeElements覆盖适当类型的每个字段：

public static XmlAttributeOverrides GetAttributeOverrides(IEnumerable<Type> typesToOverride)
{
    var overrides = typesToOverride
        .SelectMany(x => x.GetFields())  // Get a flat list of fields from all the types
        .Where(f => f.FieldType == typeof (BaseType))  // Must have the right type
        .Select(f => new
        {
            Field = f,
            Attributes = GetXmlAttributes(f)
        })
        .Where(f => f.Attributes != null)
        .Aggregate(
            new XmlAttributeOverrides(),
            (ov, field) =>
            { 
                ov.Add(field.Field.DeclaringType, field.Field.Name, field.Attributes); 
                return ov;
            });
    return overrides;
}

（是啊，我滥用Aggregate; LinQ 真是一把简洁的金锤子）

最后使用XmlAttributeOverrides创建序列化器的实例：

var attrOverrides = GetAttributeOverrides(TypesToDecorate);
serializer = new XmlSerializer(typeof(ItemCollection), attrOverrides);

您可能希望将该序列化程序缓存在静态变量中以避免泄漏程序集。

这段代码可以推广到修饰属性和字段。这留给读者作为练习。