c# - 反序列化具有未知元素顺序的 XML

Question

我正在尝试为具有真正缺陷规范的服务实现客户端。它类似于 SOAP，尽管它没有 WSDL 或等效文件。该规范也没有提供有关元素正确排序的任何信息——它们在规范中按字母顺序列出，但如果它们在请求中顺序不正确(所述顺序由检查示例)。

我可以使用它来提交请求，即使这很痛苦。但是，我不知道如何正确处理响应。

同时使用 SoapEnvelope 和直接使用 XmlSerializer，如果响应包含我尚未正确排序的元素，它将显示为 null 在我的对象上。再一次，我可以设法使用它，并手动对类属性进行排序 with Order attributes ，但我无法判断原始 XML 是否有一个我没有正确排序的字段，因此保留为 null。

这让我想到了当前的问题:我如何检查 XmlSerializer 是否丢弃了一个字段？

Answer 1

您可以使用 XmlSerializer.UnknownElement XmlSerializer 上的事件以捕获无序元素。这将允许您手动查找和修复反序列化中的问题。

一个更复杂的答案是在序列化时正确排序元素，但在反序列化时忽略顺序。这需要使用 XmlAttributes类和 XmlSerializer(Type, XmlAttributeOverrides)构造函数。请注意，以这种方式构造的序列化程序 must be cached in a hash table and resused以避免严重的内存泄漏，因此该解决方案有点“挑剔”，因为 Microsoft 没有提供有意义的 GetHashCode()对于 XmlAttributeOverrides .以下是一种可能的实现方式，它取决于提前了解所有需要其 XmlElementAttribute.Order 的类型和 XmlArrayAttribute.Order属性被忽略，从而避免了创建复杂的自定义哈希方法的需要:

 // https://stackoverflow.com/questions/33506708/deserializing-xml-with-unknown-element-order
public class XmlSerializerFactory : XmlOrderFreeSerializerFactory
{
    static readonly XmlSerializerFactory instance;

    // Use a static constructor for lazy initialization.
    private XmlSerializerFactory()
        : base(new[] { typeof(Type2), typeof(Type1), typeof(TestClass), typeof(Type3) }) // These are the types in your client for which Order needs to be ignored whend deserializing
    {
    }

    static XmlSerializerFactory()
    {
        instance = new XmlSerializerFactory();
    }

    public static XmlSerializerFactory Instance { get { return instance; } }
}

public abstract class XmlOrderFreeSerializerFactory
{
    readonly XmlAttributeOverrides overrides;
    readonly object locker = new object();
    readonly Dictionary<Type, XmlSerializer> serializers = new Dictionary<Type, XmlSerializer>();

    static void AddOverrideAttributes(Type type, XmlAttributeOverrides overrides)
    {
        if (type == null || type == typeof(object) || type.IsPrimitive || type == typeof(string))
            return;

        var mask = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public;
        foreach (var member in type.GetProperties(mask).Cast<MemberInfo>().Union(type.GetFields(mask)))
        {
            XmlAttributes overrideAttr = null;
            foreach (var attr in member.GetCustomAttributes<XmlElementAttribute>())
            {
                overrideAttr = overrideAttr ?? new XmlAttributes();
                overrideAttr.XmlElements.Add(new XmlElementAttribute { DataType = attr.DataType, ElementName = attr.ElementName, Form = attr.Form, IsNullable = attr.IsNullable, Namespace = attr.Namespace, Type = attr.Type });
            }
            foreach (var attr in member.GetCustomAttributes<XmlArrayAttribute>())
            {
                overrideAttr = overrideAttr ?? new XmlAttributes();
                overrideAttr.XmlArray = new XmlArrayAttribute { ElementName = attr.ElementName, Form = attr.Form, IsNullable = attr.IsNullable, Namespace = attr.Namespace };
            }
            foreach (var attr in member.GetCustomAttributes<XmlArrayItemAttribute>())
            {
                overrideAttr = overrideAttr ?? new XmlAttributes();
                overrideAttr.XmlArrayItems.Add(attr);
            }
            foreach (var attr in member.GetCustomAttributes<XmlAnyElementAttribute>())
            {
                overrideAttr = overrideAttr ?? new XmlAttributes();
                overrideAttr.XmlAnyElements.Add(new XmlAnyElementAttribute { Name = attr.Name, Namespace = attr.Namespace });
            }
            if (overrideAttr != null)
                overrides.Add(type, member.Name, overrideAttr);
        }
    }

    protected XmlOrderFreeSerializerFactory(IEnumerable<Type> types)
    {
        overrides = new XmlAttributeOverrides();
        foreach (var type in types.SelectMany(t => t.BaseTypesAndSelf()).Distinct())
        {
            AddOverrideAttributes(type, overrides);
        }
    }

    public XmlSerializer GetSerializer(Type type)
    {
        if (type == null)
            throw new ArgumentNullException("type");
        lock (locker)
        {
            XmlSerializer serializer;
            if (!serializers.TryGetValue(type, out serializer))
                serializers[type] = serializer = new XmlSerializer(type, overrides);
            return serializer;
        }
    }
}

public static class TypeExtensions
{
    public static IEnumerable<Type> BaseTypesAndSelf(this Type type)
    {
        while (type != null)
        {
            yield return type;
            type = type.BaseType;
        }
    }
}

然后在反序列化一个类型时，使用工厂提供的XmlSerializer。鉴于SoapEnvelope是 XmlDocument 的子类，您应该能够按照 Deserialize object property with StringReader vs XmlNodeReader 中的答案对正文节点进行反序列化.

注意——仅适度测试。演示 fiddle here .