自定义XmlSerializerOutputFormatter仅保留实际使用的命名空间

这个问题我之前做API XML输出优化时也碰到过——手动指定所有命名空间前缀会导致大量冗余声明，尤其是当你有几百个命名空间但每个接口只用少数几个的时候。分享两个我实际用过的优雅思路，不用手动反射就能解决：

方案一：序列化后通过XDocument清理未使用的命名空间 #

这个方法逻辑最直观，先完整序列化生成XML，再从实际的XML内容里收集用到的命名空间，最后移除根元素上未使用的声明。代码实现如下：

public class CustomXmlOutputFormatter : XmlSerializerOutputFormatter {
    // 先维护好前缀和命名空间的映射字典，方便统一管理
    private static readonly Dictionary<string, string> _namespacePrefixMap = new Dictionary<string, string>
    {
        {"xsi", "http://www.w3.org/2001/XMLSchema-instance"},
        {"t1", "my.namespace.one"},
        {"t2", "my.namespace.two"},
        {"t3", "my.namespace.three"},
        // 其他200+命名空间...
    };

    protected override void Serialize(XmlSerializer xmlSerializer, XmlWriter xmlWriter, object value) {
        if (value == null) {
            base.Serialize(xmlSerializer, xmlWriter, value);
            return;
        }

        // 1. 先把对象序列化为XDocument，带上所有可能的命名空间前缀
        var fullNamespaces = new XmlSerializerNamespaces(
            _namespacePrefixMap.Select(kvp => new XmlQualifiedName(kvp.Key, kvp.Value)).ToArray()
        );
        var doc = new XDocument();
        using (var tempWriter = doc.CreateWriter()) {
            xmlSerializer.Serialize(tempWriter, value, fullNamespaces);
        }

        if (doc.Root == null) {
            doc.WriteTo(xmlWriter);
            return;
        }

        // 2. 收集XML中实际用到的所有命名空间（元素、属性的命名空间都要算）
        var usedNamespaces = new HashSet<string>();
        foreach (var element in doc.DescendantsAndSelf()) {
            usedNamespaces.Add(element.Name.NamespaceName);
            foreach (var attr in element.Attributes()) {
                usedNamespaces.Add(attr.Name.NamespaceName);
            }
        }

        // 3. 移除根元素上未被使用的命名空间声明
        var unusedNamespaceAttrs = doc.Root.Attributes()
            .Where(attr => attr.IsNamespaceDeclaration && !usedNamespaces.Contains(attr.Value))
            .ToList();
        foreach (var attr in unusedNamespaceAttrs) {
            attr.Remove();
        }

        // 4. 将清理后的XML写入目标XmlWriter
        doc.WriteTo(xmlWriter);
    }
}

优点： #

• 逻辑简单易懂，不需要了解XmlSerializer内部的类型映射机制
• 能覆盖所有场景，包括动态生成的元素、通过XmlAttributeOverrides指定的命名空间
• 维护成本低，只需要更新前缀映射字典即可

注意： #

• 会多一次序列化到内存的操作，对于超大对象可能有轻微性能影响，但API场景下基本可以忽略

方案二：利用XmlReflectionImporter提前分析用到的命名空间 #

这个方法更高效，直接通过XmlSerializer内部的XmlReflectionImporter分析要序列化的类型，提前收集会用到的命名空间，再生成仅包含必要前缀的XmlSerializerNamespaces。代码示例：

public class CustomXmlOutputFormatter : XmlSerializerOutputFormatter {
    private static readonly Dictionary<string, string> _namespacePrefixMap = new Dictionary<string, string>
    {
        {"xsi", "http://www.w3.org/2001/XMLSchema-instance"},
        {"t1", "my.namespace.one"},
        {"t2", "my.namespace.two"},
        {"t3", "my.namespace.three"},
        // 其他命名空间...
    };

    protected override void Serialize(XmlSerializer xmlSerializer, XmlWriter xmlWriter, object value) {
        if (value == null) {
            base.Serialize(xmlSerializer, xmlWriter, value);
            return;
        }

        // 获取当前对象类型实际用到的命名空间前缀集合
        var usedNamespaces = GetUsedNamespaces(value.GetType());
        xmlSerializer.Serialize(xmlWriter, value, usedNamespaces);
    }

    private XmlSerializerNamespaces GetUsedNamespaces(Type objectType) {
        var importer = new XmlReflectionImporter();
        var typeMapping = importer.ImportTypeMapping(objectType);
        var usedNsSet = new HashSet<string>();

        // 收集根类型的命名空间
        if (!string.IsNullOrEmpty(typeMapping.ElementName.Namespace)) {
            usedNsSet.Add(typeMapping.ElementName.Namespace);
        }

        // 遍历所有成员，收集元素、数组、嵌套类型的命名空间
        foreach (var memberMapping in typeMapping.TypeDesc.Members) {
            switch (memberMapping) {
                case XmlElementMemberMapping elemMapping:
                    AddElementNamespace(elemMapping, usedNsSet, importer);
                    break;
                case XmlArrayMemberMapping arrayMapping:
                    AddArrayNamespace(arrayMapping, usedNsSet, importer);
                    break;
                // 可以根据需要扩展处理XmlAttributeMemberMapping等其他类型
            }
        }

        // 确保xsi命名空间被包含（通常用于nil属性）
        usedNsSet.Add(_namespacePrefixMap["xsi"]);

        // 生成仅包含必要前缀的XmlSerializerNamespaces
        var namespaces = new XmlSerializerNamespaces();
        foreach (var ns in usedNsSet) {
            var prefix = _namespacePrefixMap.First(kvp => kvp.Value == ns).Key;
            namespaces.Add(prefix, ns);
        }

        return namespaces;
    }

    private void AddElementNamespace(XmlElementMemberMapping elemMapping, HashSet<string> usedNsSet, XmlReflectionImporter importer) {
        if (!string.IsNullOrEmpty(elemMapping.Namespace)) {
            usedNsSet.Add(elemMapping.Namespace);
        }
        // 处理集合或嵌套类型的元素命名空间
        if (elemMapping.ElementType != null) {
            var elemTypeMapping = importer.ImportTypeMapping(elemMapping.ElementType);
            if (!string.IsNullOrEmpty(elemTypeMapping.ElementName.Namespace)) {
                usedNsSet.Add(elemTypeMapping.ElementName.Namespace);
            }
        }
    }

    private void AddArrayNamespace(XmlArrayMemberMapping arrayMapping, HashSet<string> usedNsSet, XmlReflectionImporter importer) {
        if (!string.IsNullOrEmpty(arrayMapping.Namespace)) {
            usedNsSet.Add(arrayMapping.Namespace);
        }
        if (arrayMapping.ElementType != null) {
            var elemTypeMapping = importer.ImportTypeMapping(arrayMapping.ElementType);
            if (!string.IsNullOrEmpty(elemTypeMapping.ElementName.Namespace)) {
                usedNsSet.Add(elemTypeMapping.ElementName.Namespace);
            }
        }
    }
}

优点： #

• 性能更好，只需要一次序列化操作
• 直接和XmlSerializer的序列化逻辑对齐，不会出现遗漏

注意： #

• 需要处理不同类型的成员映射（比如XmlElement、XmlArray等），如果你的实体类用到了更多Xml特性，可能需要扩展switch case的分支

总结 #

如果追求开发效率和维护简单，优先选方案一；如果对性能要求极高，或者需要提前知道用到的命名空间，可以选方案二。两个方案都能完美解决冗余命名空间的问题，不用手动写反射逻辑。

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