.NET 6 无需模型绑定修改JSON序列化属性名称大小写方案求助

核心思路为直接对JSON节点结构做递归遍历，对所有属性名应用小驼峰命名规则，全程不需要绑定到实体模型即可完成转换，完全规避原生JsonElement/JsonNode序列化时忽略PropertyNaming配置的问题。

方案1：基于JsonElement实现 #

兼容性更强，支持所有.NET Core 3.0+版本：

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

public static class JsonPropertyNameConverter
{
    private static readonly JsonNamingPolicy _camelCasePolicy = JsonNamingPolicy.CamelCase;

    // 对外暴露的转换方法：输入原JSON字符串，输出小驼峰格式JSON字符串
    public static string ConvertToCamelCaseJson(string inputJson)
    {
        using var doc = JsonDocument.Parse(inputJson);
        var convertedNode = ProcessJsonElement(doc.RootElement);
        return JsonSerializer.Serialize(convertedNode, new JsonSerializerOptions { WriteIndented = true });
    }

    // 递归处理任意类型的JsonElement节点
    private static JsonNode? ProcessJsonElement(JsonElement element)
    {
        return element.ValueKind switch
        {
            JsonValueKind.Object => ProcessObjectElement(element),
            JsonValueKind.Array => ProcessArrayElement(element),
            _ => JsonNode.Parse(element.GetRawText())
        };
    }

    // 处理JSON对象：转换所有属性名为小驼峰
    private static JsonObject ProcessObjectElement(JsonElement element)
    {
        var jsonObj = new JsonObject();
        foreach (var property in element.EnumerateObject())
        {
            var camelCaseName = _camelCasePolicy.ConvertName(property.Name);
            jsonObj[camelCaseName] = ProcessJsonElement(property.Value);
        }
        return jsonObj;
    }

    // 处理JSON数组：遍历处理数组内每个元素
    private static JsonArray ProcessArrayElement(JsonElement element)
    {
        var jsonArray = new JsonArray();
        foreach (var item in element.EnumerateArray())
        {
            jsonArray.Add(ProcessJsonElement(item));
        }
        return jsonArray;
    }
}

使用示例 #

// 测试用原JSON
var originalJson = """
{
    "MyPoperty" : 5,
    "MyComplexProperty" : {
        "MyOtherProperty": "value",
        "MyThirdProperty": true
    }
}
""";

// 转换得到小驼峰JSON
var camelCaseJson = JsonPropertyNameConverter.ConvertToCamelCaseJson(originalJson);

方案2：基于JsonNode的轻量实现 #

.NET 6+版本可使用该方案，代码更简洁：

public static class JsonPropertyNameConverter
{
    public static string ConvertToCamelCaseWithJsonNode(string inputJson)
    {
        var rootNode = JsonNode.Parse(inputJson);
        ProcessJsonNode(rootNode);
        return rootNode!.ToJsonString(new JsonSerializerOptions { WriteIndented = true });
    }

    private static void ProcessJsonNode(JsonNode? node)
    {
        if (node is JsonObject jsonObj)
        {
            // 先缓存原有属性避免修改时遍历异常
            var properties = jsonObj.ToList();
            foreach (var (name, value) in properties)
            {
                jsonObj.Remove(name);
                var camelCaseName = JsonNamingPolicy.CamelCase.ConvertName(name);
                jsonObj[camelCaseName] = value;
                ProcessJsonNode(value);
            }
        }
        else if (node is JsonArray jsonArray)
        {
            foreach (var item in jsonArray)
            {
                ProcessJsonNode(item);
            }
        }
    }
}

两种方案均支持任意层级的嵌套JSON、数组结构，兼容已有小驼峰属性的场景，转换结果完全匹配需求示例。

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