给定 XSD 如何在 C# 中进行多态反序列化？

Question

我有以下内容：

1) XML 架构，XSD 文件，使用 XSD.EXE 工具编译为 C# classes。

2) 一个 RabbitMQ 消息队列，其中包含 XML 中 XML 架构中定义的任何类型的格式良好的消息。以下是不同消息的两个片段：

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<UserReport xmlns=".../v5.1"; ... >
    ... User report message content... 
</UserReport>

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<CaptureReport xmlns=".../v5.1"; ...>
    ... Capture report message content... 
</CaptureReport>

3) 在类型已知时使用 XmlSerializer .Net class 进行反序列化的经验。

问题是当类型未知时如何将来自 XML 的消息反序列化为一个对象。无法实例化 XmlSerializer，因为类型未知。

一种方法是遍历所有可能的类型，直到反序列化成功，这是一个糟糕的解决方案，因为 XML 架构中定义了许多不同的类型。

还有其他选择吗？

Answer 1

根据您在 XML 本身实现多态性的准确程度，您可以采用几种方法。

元素名就是类型名（反射方式）

您可以这样获取根元素名称：

string rootElement = null;

using (XmlReader reader = XmlReader.Create(xmlFileName))
{
    while (reader.Read())
    {
        // We won't have to read much of the file to find the root element as it will be the first one found
        if (reader.NodeType == XmlNodeType.Element)
        {
            rootElement = reader.Name;
            break;
        }
    }
}

然后你可以像这样通过反射找到类型（如果你的类在不同的程序集中，请根据需要调整反射）：

var serializableType = Type.GetType("MyApp." + rootElement);
var serializer = new XmlSerializer(serializableType);

如果性能很重要，建议您缓存从元素名称到 XML 序列化程序的映射。

元素名称映射到类型名称

如果 XML 元素名称与类型名称不同，或者您不想进行反射，则可以从 XML 到 XmlSerializer 对象，但仍然使用上面的代码片段查找根元素名称。

通过xsi:type

具有多态性的公共根元素

如果您的 XML 消息都具有相同的根元素名称，并且通过使用 xsi:type 识别类型来实现多态性，那么您可以这样做：

using System;
using System.Xml.Serialization;

namespace XmlTest
{
    public abstract class RootElement
    {
    }

    public class TypeA : RootElement
    {
        public string AData
        {
            get;
            set;
        }
    }

    public class TypeB : RootElement
    {
        public int BData
        {
            get;
            set;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var serializer = new System.Xml.Serialization.XmlSerializer(typeof(RootElement),
                new Type[]
                {
                    typeof(TypeA),
                    typeof(TypeB)
                });
            RootElement rootElement = null;
            string axml = "<RootElement xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"TypeA\"><AData>Hello A</AData></RootElement>";
            string bxml = "<RootElement xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"TypeB\"><BData>1234</BData></RootElement>";

            foreach (var s in new string[] { axml, bxml })
            {
                using (var reader = new System.IO.StringReader(s))
                {
                    rootElement = (RootElement)serializer.Deserialize(reader);
                }

                TypeA a = rootElement as TypeA;

                if (a != null)
                {
                    Console.WriteLine("TypeA: {0}", a.AData);
                }
                else
                {
                    TypeB b = rootElement as TypeB;

                    if (b != null)
                    {
                        Console.WriteLine("TypeB: {0}", b.BData);
                    }
                    else
                    {
                        Console.Error.WriteLine("Unexpected type.");
                    }
                }
            }
        }
    }
}

请注意 XmlSerializer 构造函数的第二个参数，它是您希望 .NET 序列化程序了解的其他类型的数组。

Answer 2

这是一个基于@softwareness 的答案，但它提供了一些自动化。

如果您的类是通过 xsd 生成的，那么所有根类型都用 XmlRootAttribute 修饰，因此我们可以使用它：

public class XmlVariantFactory
{
    private readonly Dictionary<string, Type> _xmlRoots;

    public XmlVariantFactory() : this(Assembly.GetExecutingAssembly().GetTypes())
    {
    }

    public XmlVariantFactory(IEnumerable<Type> types)
    {
        _xmlRoots = types
                    .Select(t => new {t, t.GetCustomAttribute<XmlRootAttribute>()?.ElementName})
                    .Where(x => !string.IsNullOrEmpty(x.ElementName))
                    .ToDictionary(x => x.ElementName, x => x.t);
    }

    public Type GetSerializationType(XmlReader reader)
    {
        while (reader.Read())
        {
            if (reader.NodeType == XmlNodeType.Element)
            {
                return _xmlRoots[reader.LocalName];
            }
        }
        throw new ArgumentException("No known root type found for passed XML");
    }
}

它在执行程序集时扫描所有类型并找到所有可能的 XML 根。您可以为所有程序集执行此操作：

public XmlVariantFactory() : this(AppDomain.CurrentDomain.SelectMany(a => a.GetTypes())
{
}

然后你就可以使用它了：

var input = new StringReader(TestResource.firstRequestResponse);
var serializationType = new XmlVariantFactory().GetSerializationType(XmlReader.Create(input));
var xmlReader = XmlReader.Create(input);
bool canDeserialize = new XmlSerializer(serializationType).CanDeserialize(xmlReader);
Assert.True(canDeserialize);

Answer 3

XML 架构的负责人已将 xml-tag 添加到 RabbitMQ 协议 header 的内容字段中。 header 保存 dto 的标签，数据传输 object，发送并序列化到 xml。这意味着 IOC 容器变得得心应手。我已经编写了一个 dto 构建器接口及其由通用构建器实现的代码。因此，当为通用部分指定 dto class 时，构建器将构建一个 dto。请注意 dto-class 是由 xsd-tool 生成的。在像 MS Unity 这样的 IOC 容器中，我为所有 classes 注册了构建器接口实现，并将 xml-tag 添加到注册调用中。 IOC 容器的 resolver 函数使用从 RabbitMQ header 实际接收到的 xml-tag 来调用，以实例化 dto 的特定构建器。

给定 XSD 如何在 C# 中进行多态反序列化？

How to do a polymorphic deserialization in C# given a XSD?

c#

polymorphism

serialization

xsd

元素名就是类型名（反射方式）

元素名称映射到类型名称

通过xsi:type