.NET DataContract序列化递归过深引发StackOverflowException求助

针对你遇到的递归深度过高引发栈溢出的问题，我整理了几个无需修改现有对象模型的可行方案，优先推荐基于DataContract扩展能力的方案，既能解决问题又能保留原有代码结构：

方案1：通过DataContractSurrogate调整序列化顺序 + PreserveObjectReferences #

这个方案的核心是让序列化器优先序列化所有顶层子对象，再处理它们之间的交叉引用，这样当后续遇到交叉引用时，目标对象已经被序列化过，序列化器会自动用引用而非递归序列化，从而大幅降低递归深度。

实现步骤： #

1. 创建自定义的IDataContractSurrogate，动态调整属性的序列化顺序：
   • 将根对象A的直接子属性（B、C、D、E、F）的Order设为低优先级（比如1），确保它们先被序列化
   • 将子对象间的交叉引用属性（比如B的C属性、C的D属性等）的Order设为高优先级（比如100），延后处理
2. 开启PreserveObjectReferences，让序列化器自动跟踪已序列化的对象，遇到重复引用时只写入引用标识而非递归序列化

示例代码： #

public class CrossReferenceSurrogate : IDataContractSurrogate
{
    public Type GetDataContractType(Type type) => type;

    public object GetObjectToSerialize(object obj, Type targetType) => obj;

    public object GetDeserializedObject(object obj, Type targetType) => obj;

    public object GetCustomDataToExport(Type clrType, Type dataContractType) => null;

    public object GetCustomDataToExport(MemberInfo memberInfo, Type dataContractType) => null;

    public void GetKnownCustomDataTypes(Collection<Type> customDataTypes) { }

    public Type GetReferencedTypeOnImport(string typeName, string typeNamespace, object customData) => null;

    public CodeTypeDeclaration ProcessImportedType(CodeTypeDeclaration typeDeclaration, CodeCompileUnit compileUnit) => typeDeclaration;

    public DataMemberInfo GetDataMemberInfo(MemberInfo memberInfo, Type dataContractType)
    {
        var dataMemberAttr = memberInfo.GetCustomAttribute<DataMemberAttribute>();
        if (dataMemberAttr == null) return null;

        // 优先序列化A的直接子对象
        if (memberInfo.DeclaringType == typeof(A) && 
            new[] { "B", "C", "D", "E", "F" }.Contains(memberInfo.Name))
        {
            return new DataMemberInfo(memberInfo, dataMemberAttr.Name, 1, dataMemberAttr.IsRequired, dataMemberAttr.EmitDefaultValue);
        }

        // 延后序列化交叉引用属性
        var crossRefMembers = new Dictionary<Type, string>
        {
            { typeof(B), "C" },
            { typeof(C), "D" },
            { typeof(D), "E" },
            { typeof(E), "F" }
        };
        if (crossRefMembers.TryGetValue(memberInfo.DeclaringType, out var refPropName) && memberInfo.Name == refPropName)
        {
            return new DataMemberInfo(memberInfo, dataMemberAttr.Name, 100, dataMemberAttr.IsRequired, dataMemberAttr.EmitDefaultValue);
        }

        // 其他属性保持原顺序
        return new DataMemberInfo(memberInfo, dataMemberAttr.Name, dataMemberAttr.Order, dataMemberAttr.IsRequired, dataMemberAttr.EmitDefaultValue);
    }
}

使用方式： #

var settings = new DataContractSerializerSettings
{
    PreserveObjectReferences = true,
    DataContractSurrogate = new CrossReferenceSurrogate(),
    MaxItemsInObjectGraph = 6000000 // 适配你的600万对象规模
};

var serializer = new DataContractSerializer(typeof(A), settings);

// 执行序列化
using (var stream = new FileStream("output.xml", FileMode.Create))
{
    serializer.WriteObject(stream, yourAInstance);
}

这个方案完全不需要修改原有对象模型，所有调整都通过代理实现，能有效将递归深度从5500降低到2左右，彻底避免栈溢出。

方案2：手动实现广度优先序列化（自定义逻辑） #

如果方案1的灵活性不够，你可以完全手动控制序列化流程，采用广度优先遍历对象图，彻底规避递归：

核心思路： #

1. 先序列化根对象A，再序列化所有A的直接子对象（B、C、D、E、F），并为每个对象分配唯一ID
2. 遍历所有子对象的交叉引用属性，只写入目标对象的ID而非递归序列化
3. 反序列化时先读取所有对象到字典，再根据ID恢复交叉引用

简化示例： #

public class BreadthFirstSerializer
{
    private readonly Dictionary<object, string> _objectIdMap = new();
    private int _idCounter = 0;

    public void Serialize(A a, Stream stream)
    {
        using var writer = XmlWriter.Create(stream);
        writer.WriteStartElement("A");

        // 先序列化所有直接子对象并分配ID
        SerializeChildObject(writer, a.B, "B");
        SerializeChildObject(writer, a.C, "C");
        SerializeChildObject(writer, a.D, "D");
        SerializeChildObject(writer, a.E, "E");
        SerializeChildObject(writer, a.F, "F");

        // 再序列化交叉引用
        SerializeCrossRef(writer, a.B, "B_C");
        SerializeCrossRef(writer, a.C, "C_D");
        SerializeCrossRef(writer, a.D, "D_E");
        SerializeCrossRef(writer, a.E, "E_F");

        writer.WriteEndElement();
    }

    private void SerializeChildObject(XmlWriter writer, object obj, string elementName)
    {
        if (obj == null) return;
        var id = $"obj_{_idCounter++}";
        _objectIdMap[obj] = id;

        writer.WriteStartElement(elementName);
        writer.WriteAttributeString("id", id);

        // 序列化对象的非引用属性（根据实际类型调整）
        if (obj is B b) writer.WriteElementString("Value", b.SomeValue.ToString());
        if (obj is C c) writer.WriteElementString("Value", c.SomeValue.ToString());

        writer.WriteEndElement();
    }

    private void SerializeCrossRef(XmlWriter writer, object obj, ref string elementName)
    {
        if (obj is B b && b.C != null)
        {
            writer.WriteStartElement(elementName);
            writer.WriteAttributeString("ref", _objectIdMap[b.C]);
            writer.WriteEndElement();
        }
        // 同理处理其他交叉引用
    }

    // 反序列化逻辑类似，先读取所有对象到字典，再根据ID恢复引用
}

这个方案完全掌控序列化流程，适合极端复杂的交叉引用场景，但需要手动处理每个类型的序列化逻辑，工作量较大。

方案3：临时调整栈大小（不推荐） #

作为应急方案，可以通过修改项目属性或链接器选项调整应用程序的栈大小（Windows默认栈大小为1MB，最大可调整到8MB左右），但这只是治标不治本，递归深度超过栈大小限制时仍会出错，不适合长期使用。

内容的提问来源于stack exchange，提问作者M.G.