XSD 1.0无法验证无序XML，求C#下的有效解决方案

针对你需要验证的MyInfo类型XML规则（0/1个A元素、任意数量B元素、顺序任意），以及生产环境30个类似字段的场景，C#里没有直接“彻底禁用XSD顺序验证”的全局开关，但有两种更优雅的方案替代当前的choice+额外校验方式：

方案1：使用XSD 1.1的断言（Assert）实现 #

XSD 1.1支持通过断言（xs:assert）直接在Schema中定义元素数量限制，同时结合xs:choice maxOccurs="unbounded"允许元素任意顺序出现，完全不需要额外代码校验。

示例XSD结构 #

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
           xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning" 
           vc:minVersion="1.1">
  <xs:complexType name="MyInfo">
    <!-- 允许A/B元素任意顺序、任意次数出现 -->
    <xs:choice maxOccurs="unbounded">
      <xs:element name="A" type="xs:string" minOccurs="0" maxOccurs="1"/>
      <xs:element name="B" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
    </xs:choice>
    <!-- 断言限制A元素最多出现1次 -->
    <xs:assert test="count(A) le 1"/>
  </xs:complexType>
</xs:schema>

C#中启用XSD 1.1验证 #

默认情况下.NET的XML验证只支持XSD 1.0，需要手动开启1.1特性：

var schemaSet = new XmlSchemaSet();
// 启用XSD 1.1支持
schemaSet.XmlSchemaCompilerSettings = new XmlSchemaCompilerSettings { EnableXsd11Features = true };
schemaSet.Add(null, "MyInfoSchema.xsd");

var validationSettings = new XmlReaderSettings
{
    Schemas = schemaSet,
    ValidationType = ValidationType.Schema,
    ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings
};
// 绑定验证事件处理
validationSettings.ValidationEventHandler += (sender, e) =>
{
    if (e.Severity == XmlSeverityType.Error)
        throw new InvalidOperationException($"XML验证失败：{e.Message}");
};

// 执行验证
using var xmlReader = XmlReader.Create("target.xml", validationSettings);
while (xmlReader.Read()) { }

这种方式最适合你的场景——30个类似字段只需在各自的complexType中添加对应的断言规则，统一通过Schema完成所有校验，无需额外逻辑。

方案2：自定义XmlSchemaValidator忽略顺序验证 #

如果环境限制无法使用XSD 1.1，可以通过继承XmlSchemaValidator重写验证逻辑，跳过元素顺序检查，只保留元素数量和类型的校验。

自定义验证器实现 #

public class IgnoreOrderSchemaValidator : XmlSchemaValidator
{
    private readonly Dictionary<XmlQualifiedName, int> _elementOccurrences = new();
    private readonly XmlSchemaComplexType _targetType;

    public IgnoreOrderSchemaValidator(XmlNameTable nameTable, XmlSchemaSet schemaSet, 
                                      XmlNamespaceManager namespaceManager, XmlSchemaComplexType targetType)
        : base(nameTable, schemaSet, namespaceManager)
    {
        _targetType = targetType;
    }

    public override void ValidateElement(string localName, string namespaceUri, XmlSchemaInfo schemaInfo)
    {
        // 记录元素出现次数
        var elementQName = new XmlQualifiedName(localName, namespaceUri);
        _elementOccurrences.TryGetValue(elementQName, out var count);
        _elementOccurrences[elementQName] = count + 1;

        // 跳过顺序校验，直接验证元素本身的合法性
        base.ValidateElement(localName, namespaceUri, schemaInfo);
    }

    public override void EndValidation()
    {
        // 校验所有元素的出现次数是否符合Schema定义
        foreach (var element in _targetType.Particles
                     .OfType<XmlSchemaChoice>()
                     .SelectMany(choice => choice.Items.OfType<XmlSchemaElement>()))
        {
            var qName = element.QualifiedName;
            var actualCount = _elementOccurrences.TryGetValue(qName, out var cnt) ? cnt : 0;

            if (actualCount > element.MaxOccurs)
                throw new ValidationException($"元素 {qName.LocalName} 出现次数超出限制，最多允许 {element.MaxOccurs} 次");
            if (actualCount < element.MinOccurs)
                throw new ValidationException($"元素 {qName.LocalName} 出现次数不足，至少需要 {element.MinOccurs} 次");
        }

        base.EndValidation();
    }
}

使用自定义验证器 #

var schemaSet = new XmlSchemaSet();
schemaSet.Add(null, "MyInfoSchema.xsd");
// 获取目标complexType
var myInfoType = schemaSet.GlobalTypes.Values
    .OfType<XmlSchemaComplexType>()
    .First(t => t.Name == "MyInfo");

var nameTable = new NameTable();
var nsManager = new XmlNamespaceManager(nameTable);

using var xmlReader = XmlReader.Create("target.xml", new XmlReaderSettings { NameTable = nameTable });
var validator = new IgnoreOrderSchemaValidator(nameTable, schemaSet, nsManager, myInfoType);

// 开始验证根元素
validator.ValidateElement("MyInfo", "", null);
while (xmlReader.Read())
{
    if (xmlReader.NodeType == XmlNodeType.Element)
        validator.ValidateElement(xmlReader.LocalName, xmlReader.NamespaceURI, null);
    else if (xmlReader.NodeType == XmlNodeType.EndElement)
        validator.EndElement(null);
}
// 完成最终校验
validator.EndValidation();

总结 #

• 优先选择XSD 1.1断言方案：代码侵入性低，Schema规则统一，适合大量类似字段的场景；
• 若无法使用XSD 1.1，再用自定义验证器：完全控制验证逻辑，灵活适配各种规则。

内容的提问来源于stack exchange，提问作者eocron