如何仅反序列化JSON子树？使用System.Text.Json将指定JSON结构中的inner节点反序列化为MyType类型

针对你提出的两个问题（包括具体的outer->inner节点反序列化场景），我整理了三种常用的实现方式，每种都有适用的场景，你可以根据需求选择：

方法一：用JsonDocument定位子节点后反序列化（最直观） #

这是最常用的方式，先把整个JSON解析成JsonDocument，然后逐层导航到目标子树，再单独反序列化这个节点。优点是代码简单，不需要额外定义类，适合临时提取子节点的场景。

针对你的示例JSON { "outer":{ "inner":{ ... } } }，代码如下：

using System.Text.Json;

// 假设jsonString是你的JSON文本
string jsonString = "{ \"outer\":{ \"inner\":{ \"property1\": \"value1\", \"property2\": 2 } } }";

// 解析JSON到JsonDocument（注意用using，因为JsonDocument是IDisposable）
using var jsonDoc = JsonDocument.Parse(jsonString);

// 逐层导航到inner节点
JsonElement innerElement = jsonDoc.RootElement
    .GetProperty("outer") // 获取outer属性对应的节点
    .GetProperty("inner"); // 获取inner属性对应的节点

// 将inner节点反序列化为MyType类型
MyType myInstance = JsonSerializer.Deserialize<MyType>(innerElement);

注意：如果JSON可能不存在outer或inner节点，建议先用TryGetProperty方法判断，避免抛出异常。

方法二：用流式读取（适合超大JSON） #

如果你的JSON文件特别大，加载整个JsonDocument会占用过多内存，这时可以用Utf8JsonReader流式读取，跳过不需要的节点，直接定位到inner节点再反序列化。这种方法内存占用更低，但代码稍复杂：

using System.Text.Json;
using System.Text;

string jsonString = "{ \"outer\":{ \"inner\":{ \"property1\": \"value1\", \"property2\": 2 } } }";
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
using var reader = new Utf8JsonReader(stream);

MyType myInstance = null;

// 遍历JSON令牌，直到找到inner节点
while (reader.Read())
{
    // 找到outer属性
    if (reader.TokenType == JsonTokenType.PropertyName && reader.GetString() == "outer")
    {
        reader.Read(); // 读取outer的StartObject令牌
        // 在outer对象内找inner属性
        while (reader.Read())
        {
            if (reader.TokenType == JsonTokenType.PropertyName && reader.GetString() == "inner")
            {
                reader.Read(); // 读取inner的StartObject令牌
                // 反序列化当前节点为MyType
                myInstance = JsonSerializer.Deserialize<MyType>(ref reader);
                break;
            }
            // 跳过其他嵌套的对象/数组，避免读取混乱
            else if (reader.TokenType is JsonTokenType.StartObject or JsonTokenType.StartArray)
            {
                reader.Skip();
            }
        }
        break;
    }
    // 跳过根对象外的其他节点（如果有的话）
    else if (reader.TokenType is JsonTokenType.StartObject or JsonTokenType.StartArray)
    {
        reader.Skip();
    }
}

方法三：定义包装类（适合重复使用场景） #

如果需要多次处理这种嵌套结构，也可以定义一个匹配外层结构的包装类，直接反序列化整个JSON后提取目标节点。优点是代码简洁，可读性好：

using System.Text.Json;

// 定义外层包装类
public class OuterWrapper
{
    public InnerWrapper Outer { get; set; }
}

public class InnerWrapper
{
    public MyType Inner { get; set; }
}

// 反序列化并提取inner节点
string jsonString = "{ \"outer\":{ \"inner\":{ \"property1\": \"value1\", \"property2\": 2 } } }";
var wrapper = JsonSerializer.Deserialize<OuterWrapper>(jsonString);
MyType myInstance = wrapper?.Outer?.Inner;

以上三种方法各有优劣，你可以根据JSON的大小、使用频率来选择最合适的方案~

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