我给出以下内容：

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

2) RabbitMQ 消息队列，包含 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 类进行反序列化的经验。

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

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

还有其他选择吗？

您可以采取几种方法，具体取决于您在 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 元素名称与类型名称不同，或者您不想进行反射，则可以创建一个Dictionary从 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 序列化程序了解的其他类型的数组。