C#大型复杂对象反序列化触发OutOfMemoryException问题求助

兄弟，我之前也踩过超大XML反序列化内存爆掉的坑——480MB的XML在内存里会膨胀好几倍（XML本身是文本格式，加上对象实例的开销，轻松破几个G），默认的序列化器都是一次性加载整个文档，不爆才怪。结合你说的不能改类结构的限制，给你几个能直接落地的方案：

1. 最靠谱：XML流式逐节点处理 #

核心思路是不把整个XML文档加载到内存，而是用XmlReader逐个节点读取、反序列化，这样内存占用只保留当前处理的几个对象，完全不会爆内存。

方案A：手动映射节点到类（灵活可控） #

自己写逻辑用XmlReader遍历节点，把属性和元素值手动赋值到你的类实例里，适合对XML结构非常熟悉的场景，比如：

using System.Xml;

public SiXmlPlugin DeserializeLargeXml(string filePath)
{
    var plugin = new SiXmlPlugin();
    using (var reader = XmlReader.Create(filePath, new XmlReaderSettings { IgnoreWhitespace = true }))
    {
        // 定位到<Plugin>根节点
        while (reader.Read() && reader.Name != "Plugin") {}

        // 读取根节点的属性
        plugin.Name = reader.GetAttribute("Name");
        plugin.Version = long.Parse(reader.GetAttribute("Version"));
        plugin.VersionString = reader.GetAttribute("VersionString");

        // 处理根节点下的所有<File>
        while (reader.ReadToFollowing("File"))
        {
            var file = new SiFile
            {
                Filename = reader.GetAttribute("Filename")
            };
            // 读取<Content>元素内容
            if (reader.ReadToDescendant("Content"))
            {
                file.Content = reader.ReadElementContentAsString();
            }
            plugin.Files.Add(file);
        }

        // 处理根节点下的所有<Folder>，递归处理子文件夹和文件
        while (reader.ReadToFollowing("Folder"))
        {
            var folder = ReadFolderRecursive(reader);
            plugin.Folders.Add(folder);
        }
    }
    return plugin;
}

// 递归读取Folder及其子节点
private SiFolder ReadFolderRecursive(XmlReader reader)
{
    var folder = new SiFolder { Name = reader.GetAttribute("Name") };

    // 读取当前Folder下的<File>
    while (reader.ReadToFollowing("File") && reader.ParentNode?.Name == "Folder")
    {
        var file = new SiFile
        {
            Filename = reader.GetAttribute("Filename")
        };
        if (reader.ReadToDescendant("Content"))
        {
            file.Content = reader.ReadElementContentAsString();
        }
        folder.Files.Add(file);
    }

    // 读取当前Folder下的子<Folder>
    while (reader.ReadToFollowing("Folder") && reader.ParentNode?.Name == "Folder")
    {
        var subFolder = ReadFolderRecursive(reader);
        folder.Folders.Add(subFolder);
    }

    return folder;
}

方案B：结合XmlSerializer逐对象反序列化（简洁高效） #

不想手动写映射？可以用XmlSerializer单独反序列化每个子对象（比如单个SiFile、SiFolder），同样基于XmlReader流式处理：

using System.Xml.Serialization;

public SiXmlPlugin DeserializeLargeXmlWithSerializer(string filePath)
{
    var plugin = new SiXmlPlugin();
    var fileSerializer = new XmlSerializer(typeof(SiFile));
    var folderSerializer = new XmlSerializer(typeof(SiFolder));

    using (var reader = XmlReader.Create(filePath, new XmlReaderSettings { IgnoreWhitespace = true }))
    {
        // 定位到根节点并读取属性
        while (reader.Read() && reader.Name != "Plugin") {}
        plugin.Name = reader.GetAttribute("Name");
        plugin.Version = long.Parse(reader.GetAttribute("Version"));
        plugin.VersionString = reader.GetAttribute("VersionString");

        // 反序列化所有<File>
        while (reader.ReadToFollowing("File"))
        {
            var file = (SiFile)fileSerializer.Deserialize(reader);
            plugin.Files.Add(file);
        }

        // 反序列化所有<Folder>
        while (reader.ReadToFollowing("Folder"))
        {
            var folder = (SiFolder)folderSerializer.Deserialize(reader);
            plugin.Folders.Add(folder);
        }
    }
    return plugin;
}

这个方案利用了XmlSerializer的能力，不用手动处理每个属性，代码更简洁，同时保持流式的低内存特性。

2. 辅助优化：提升应用内存上限 #

如果流式处理暂时不好落地，可以先做这个应急：

• 确保你的程序在64位系统上运行（32位程序最多只能用~2GB内存，很容易爆）
• 开启大地址感知（LAA）：在项目属性里设置，或者用editbin工具修改exe，让32位程序能用到3GB内存（但还是不如64位）

不过这个只是缓解，治标不治本，流式处理才是根本解决方案。

关于BinarySerializer和protobuf-net的说明 #

这两个序列化器本身是基于对象图的，默认会把整个对象加载到内存才能反序列化，所以对于480MB的超大对象来说，OutOfMemory是必然的。除非你自己实现自定义的流式序列化逻辑，但考虑到你的源数据是XML，还是优先用XML流式处理更直接。

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