以未知元素顺序反序列化 XML

Question

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

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

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

这让我想到了当前的问题：如何检查 XmlSerializer 是否删除了一个字段？

Answer 1

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

一个更复杂的答案是在序列化时正确排序元素，但在反序列化时忽略顺序。这需要使用忽略的 XmlAttributes class and the XmlSerializer(Type, XmlAttributeOverrides) constructor. Note that serializers constructed in this manner must be cached in a hash table and resused to avoid a severe memory leak, and thus this solution is a little "finicky" since Microsoft doesn't provide a meaningful GetHashCode() for XmlAttributeOverrides. The following is one possible implementation which depends upon knowing in advance all types that need their XmlElementAttribute.Order and XmlArrayAttribute.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 };
            }
            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 is a subclass of XmlDocument, you should be able to deserialize the body node along the lines of the answer in .

以未知元素顺序反序列化 XML

Deserializing XML with unknown element order

c#

serialization

soap

xml-serialization

xmlserializer