.Net Core 处理前端动态嵌套JSON时如何自动映射到自定义POCO

你遇到的嵌套字段映射失效，本质是前端传递的JSON层级结构和当前Survey POCO的平铺属性结构不匹配，和JsonSerializerOptions的配置没有关系：

• 前端JSON中firstname/lastname是name对象下的二级嵌套字段
• 前端JSON中social是id对象下的二级嵌套字段
• 但你定义的Survey类将上述字段全部设为顶层平铺属性，没有对应嵌套结构
  序列化器默认严格按同层级、同名称匹配属性，自然无法自动将嵌套层级的值映射到平铺的POCO属性上。

方案1：自定义JsonConverter自动映射（无需改动现有Survey POCO） #

这个方案完全匹配你「不想手动逐个调用TryGetProperty、依赖序列化器自动完成映射」的需求，一次写完转换器逻辑后，后续新增字段只要按标记对应即可，适配前端仅传非空字段的特性。

实现逻辑 #

自定义针对Survey的JsonConverter，自动递归将嵌套JSON拍平为路径-键值对结构，再和你Survey类上通过[JsonPropertyName]标记的属性自动匹配赋值。

public class SurveyJsonConverter : JsonConverter<Survey>
{
    public override Survey Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        using var doc = JsonDocument.ParseValue(ref reader);
        var root = doc.RootElement;
        
        // 递归拍平所有嵌套JSON节点为 路径->值 的字典
        var flatProperties = FlattenJson(root, string.Empty);
        var survey = new Survey();

        // 遍历Survey所有可映射的属性，自动匹配对应JSON路径
        var targetProps = typeof(Survey)
            .GetProperties()
            .Select(prop => new
            {
                TargetProp = prop,
                JsonName = prop.GetCustomAttribute<JsonPropertyNameAttribute>()?.Name ?? prop.Name,
                MatchSuffix = $".{(prop.GetCustomAttribute<JsonPropertyNameAttribute>()?.Name ?? prop.Name)}".ToLower()
            });

        foreach (var item in targetProps)
        {
            // 大小写不敏感匹配拍平后的JSON路径
            var matchedKey = flatProperties.Keys.FirstOrDefault(k => k.ToLower().EndsWith(item.MatchSuffix));
            if (matchedKey == null) continue;

            var jsonValue = flatProperties[matchedKey];
            // 按属性类型完成值转换赋值，可按需扩展其他类型支持
            if (item.TargetProp.PropertyType == typeof(string))
            {
                item.TargetProp.SetValue(survey, jsonValue.GetString());
            }
            else if (item.TargetProp.PropertyType == typeof(char?))
            {
                var strVal = jsonValue.GetString();
                item.TargetProp.SetValue(survey, string.IsNullOrEmpty(strVal) ? null : strVal[0]);
            }
            else if (item.TargetProp.PropertyType == typeof(char))
            {
                var strVal = jsonValue.GetString();
                item.TargetProp.SetValue(survey, string.IsNullOrEmpty(strVal) ? '\0' : strVal[0]);
            }
            else if (item.TargetProp.PropertyType == typeof(DateTime))
            {
                item.TargetProp.SetValue(survey, jsonValue.GetDateTime());
            }
        }

        return survey;
    }

    // 递归拍平嵌套JsonElement的辅助方法
    private Dictionary<string, JsonElement> FlattenJson(JsonElement element, string parentPath)
    {
        var result = new Dictionary<string, JsonElement>();
        if (element.ValueKind != JsonValueKind.Object) return result;

        foreach (var prop in element.EnumerateObject())
        {
            var currentPath = string.IsNullOrEmpty(parentPath) ? prop.Name : $"{parentPath}.{prop.Name}";
            if (prop.Value.ValueKind == JsonValueKind.Object)
            {
                // 嵌套对象继续递归展开
                var childResults = FlattenJson(prop.Value, currentPath);
                foreach (var child in childResults)
                {
                    result[child.Key] = child.Value;
                }
            }
            else
            {
                result[currentPath] = prop.Value;
            }
        }
        return result;
    }

    public override void Write(Utf8JsonWriter writer, Survey value, JsonSerializerOptions options)
    {
        // 若需要将Survey序列化回前端的嵌套结构，可在此实现层级映射逻辑
        throw new NotImplementedException();
    }
}

配置方法 #

在你原有序列化配置中注册这个自定义转换器即可：

var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true,
    IgnoreNullValues = true,
    Converters = { new SurveyJsonConverter() }
};

var surveyModel = JsonSerializer.Deserialize<Survey>(obj, options);

方案优势 #

• 完全保留你现有已经定义好的Survey类结构，无需调整业务侧的属性访问逻辑
• 无需手动编写大量TryGetProperty的取值代码，新增属性只要按规范打[JsonPropertyName]标记即可自动映射
• 完美兼容前端仅传非空字段的特性，未传递的字段会自动保持POCO默认值

方案2：调整POCO结构对齐JSON层级（无需自定义转换器） #

如果Survey类还未深度耦合业务逻辑，可以直接将POCO的层级结构调整为和前端JSON完全一致，这是最符合序列化器默认行为的方案，不需要任何自定义逻辑。
调整后的POCO结构示例：

public class Survey
{
    [JsonPropertyName("name")]
    public NameGroup Name { get; set; }

    [JsonPropertyName("gender")]
    public char Gender { get; set; }

    [JsonPropertyName("birthdate")]
    public DateTime Birthdate { get; set; }

    [JsonPropertyName("maritalstatus")]
    public string MaritalStatus { get; set; }

    [JsonPropertyName("id")]
    public IdGroup Id { get; set; }
}

// 对应name嵌套对象下的字段
public class NameGroup
{
    [JsonPropertyName("firstname")]
    public string FirstName { get; set; }
    [JsonPropertyName("middleinitial")]
    public char MiddleInitial { get; set; }
    [JsonPropertyName("lastname")]
    public string LastName { get; set; }
    [JsonPropertyName("jrsr")]
    public string JrSr { get; set; }
}

// 对应id嵌套对象下的字段
public class IdGroup
{
    [JsonPropertyName("social")]
    public string SocialSecurityNumber { get; set; }
}

调整完成后，你原有的JsonSerializerOptions配置不需要修改，序列化器就能自动正确映射所有字段。 #

• 你当前定义的MiddleInitial、Gender等属性为非空值类型，当前端未传对应字段时，这些属性会保持值类型的默认值（比如char默认值为'\0'）。如果需要区分「未传值」和「传入默认值」的场景，建议将这些属性改为可空类型，例如public char? Gender { get; set; }。
• 方案1中的递归拍平逻辑，支持任意深度的嵌套JSON结构映射，后续前端如果调整字段的嵌套层级，只要字段名称匹配，就不需要修改转换器逻辑。

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