基于XSD清理XML冗余元素与属性的技术方案咨询

问题1：通过XSD生成XSLT是否为推荐方案？需做哪些适配？ #

这个方案适合XSD结构稳定、不需要频繁变更的场景，是可行的实践方向，但需要做好以下适配：

• 确保XSD定义完整准确：生成的XSLT完全依赖XSD规则，必须把所有合法元素、属性在XSD中明确声明，比如你的ItemProduceRecipe.xsd要精准定义允许的属性，排除junkA、junkB这类非法属性。
• 选择支持Schema到XSLT转换的工具：使用支持Schema-aware的XSLT工具（如Saxon）或专业XML编辑器（如XmlSpy）生成过滤用的XSLT，生成的XSLT要实现「只保留XSD允许的节点」的核心逻辑。
• 处理XSD复杂结构：如果XSD包含嵌套元素、可选节点、命名空间、属性默认值等规则，生成的XSLT必须对应这些逻辑，不能只处理简单扁平结构。
• 适配命名空间：若XSD带命名空间，生成的XSLT要正确处理命名空间映射，避免因命名空间不匹配误删合法节点。

问题2：是否推荐通过XSL加载XSD并移除不匹配内容？C#如何实现？ #

这个方案灵活性更高，尤其适合XSD可能动态变更的场景，非常推荐使用。以下是具体的C#实现思路和代码：

实现思路 #

核心是利用XML验证机制捕获非法节点，再遍历原XML构建只包含合法节点的新文档；或者使用支持Schema-aware的XSLT处理器直接基于XSD过滤节点。

原生.NET实现（无需第三方库） #

using System.Xml;
using System.Collections.Generic;

class XmlCleaner
{
    static void Main()
    {
        // 加载XSD Schema
        XmlSchemaSet schemaSet = new XmlSchemaSet();
        schemaSet.Add(null, "ItemProduceRecipe.xsd");
        schemaSet.Compile();

        // 配置XML读取器，启用Schema验证并捕获非法节点
        XmlReaderSettings settings = new XmlReaderSettings();
        settings.ValidationType = ValidationType.Schema;
        settings.Schemas = schemaSet;
        HashSet<string> invalidAttributes = new HashSet<string>();
        HashSet<string> invalidElements = new HashSet<string>();

        settings.ValidationEventHandler += (sender, e) =>
        {
            if (e.Severity == XmlSeverityType.Error)
            {
                // 解析错误信息，捕获非法属性
                if (e.Message.Contains("属性") && e.Message.Contains("未声明"))
                {
                    string attrName = e.Message.Split('\'')[1];
                    invalidAttributes.Add(attrName);
                }
                // 捕获非法元素
                else if (e.Message.Contains("元素") && e.Message.Contains("未声明"))
                {
                    string elemName = e.Message.Split('\'')[1];
                    invalidElements.Add(elemName);
                }
            }
        };

        // 读取原XML并写入清理后的XML
        using XmlReader reader = XmlReader.Create("ItemProduceRecipe.xml", settings);
        using XmlWriter writer = XmlWriter.Create("Cleaned_ItemProduceRecipe.xml");

        writer.WriteStartDocument();
        while (reader.Read())
        {
            switch (reader.NodeType)
            {
                case XmlNodeType.Element:
                    // 跳过非法元素
                    if (invalidElements.Contains(reader.LocalName))
                    {
                        reader.Skip();
                        break;
                    }
                    writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
                    // 只写入合法属性
                    if (reader.HasAttributes)
                    {
                        while (reader.MoveToNextAttribute())
                        {
                            if (!invalidAttributes.Contains(reader.LocalName))
                            {
                                writer.WriteAttributeString(reader.Prefix, reader.LocalName, reader.NamespaceURI, reader.Value);
                            }
                        }
                        reader.MoveToElement();
                    }
                    if (reader.IsEmptyElement)
                    {
                        writer.WriteEndElement();
                    }
                    break;
                case XmlNodeType.EndElement:
                    if (!invalidElements.Contains(reader.LocalName))
                    {
                        writer.WriteEndElement();
                    }
                    break;
                // 按需保留文本、注释、CDATA等节点
                case XmlNodeType.Text:
                    writer.WriteString(reader.Value);
                    break;
                case XmlNodeType.Comment:
                    writer.WriteComment(reader.Value);
                    break;
                case XmlNodeType.CDATA:
                    writer.WriteCData(reader.Value);
                    break;
            }
        }
        writer.WriteEndDocument();
    }
}

基于Saxon的Schema-aware XSLT实现（更高效） #

如果处理复杂XML/XSD，推荐使用Saxon的.NET版本（需安装NuGet包Saxon-HE），编写XSLT直接基于XSD过滤：

1. 编写XSLT文件（FilterInvalidNodes.xslt）：

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xsl:param name="schema-path" select="'ItemProduceRecipe.xsd'"/>
    <xsl:import-schema schema-location="{$schema-path}"/>

    <xsl:template match="@*|node()">
        <!-- 只保留XSD允许的节点 -->
        <xsl:if test="self::*[xs:type(.)] or self::@*[xs:type(.)] or self::text() or self::comment() or self::cdata()">
            <xsl:copy>
                <xsl:apply-templates select="@*[xs:type(.)]|node()"/>
            </xsl:copy>
        </xsl:if>
    </xsl:template>
</xsl:stylesheet>

2. C#执行代码：

using Saxon.Api;

class SaxonXmlCleaner
{
    static void Main()
    {
        Processor processor = new Processor(true);
        XsltCompiler compiler = processor.NewXsltCompiler();
        XsltExecutable executable = compiler.Compile(new Uri("FilterInvalidNodes.xslt"));
        XsltTransformer transformer = executable.Load();

        // 设置输入输出
        XmlDocument inputDoc = new XmlDocument();
        inputDoc.Load("ItemProduceRecipe.xml");
        transformer.InitialContextNode = processor.NewDocumentBuilder().Build(inputDoc);

        using XmlWriter outputWriter = XmlWriter.Create("Cleaned_ItemProduceRecipe.xml");
        var serializer = processor.NewSerializer(outputWriter);
        transformer.Run(serializer);
    }
}

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