使用System.Text.Json自定义反序列化：将平级字段分组映射到嵌套对象

要实现该映射需求，需自定义继承自JsonConverter<Membership>的转换器，手动处理平级字段到嵌套属性的映射，步骤如下：

1. 实现自定义JsonConverter #

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

public class MembershipJsonConverter : JsonConverter<Membership>
{
    public override Membership Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        if (reader.TokenType != JsonTokenType.StartObject)
        {
            throw new JsonException();
        }

        var membership = new Membership();
        var member = new Member();

        while (reader.Read())
        {
            if (reader.TokenType == JsonTokenType.EndObject)
            {
                membership.Member = member;
                return membership;
            }

            if (reader.TokenType != JsonTokenType.PropertyName)
            {
                throw new JsonException();
            }

            string propertyName = reader.GetString();
            reader.Read();

            // 根据属性名分配到对应对象的属性
            switch (propertyName.ToLower())
            {
                case "id":
                    member.Id = reader.GetInt32();
                    break;
                case "firstname":
                    member.FirstName = reader.GetString();
                    break;
                case "lastname":
                    member.LastName = reader.GetString();
                    break;
                case "group":
                    membership.Group = reader.GetString();
                    break;
                case "state":
                    membership.State = reader.GetString();
                    break;
                default:
                    // 忽略未定义的属性，可按需调整逻辑
                    reader.Skip();
                    break;
            }
        }

        throw new JsonException("解析JSON失败");
    }

    // 如果不需要序列化回平级JSON，可直接抛出NotImplementedException
    public override void Write(Utf8JsonWriter writer, Membership value, JsonSerializerOptions options)
    {
        writer.WriteStartObject();
        
        writer.WriteNumber("id", value.Member.Id);
        writer.WriteString("firstName", value.Member.FirstName);
        writer.WriteString("lastName", value.Member.LastName);
        writer.WriteString("group", value.Group);
        writer.WriteString("state", value.State);
        
        writer.WriteEndObject();
    }
}

2. 注册转换器并调用反序列化 #

有两种注册转换器的方式，二选一即可：

• 方式1：在JsonSerializerOptions中局部注册，仅当前序列化/反序列化操作生效：

var json = @"{
    ""id"": 123,
    ""firstName"": ""James"",
    ""lastName"": ""Smith"",
    ""group"": ""Premium"",
    ""state"": ""Active""
}";

var serializeOptions = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true,
    Converters = { new MembershipJsonConverter() }
};

var membership = JsonSerializer.Deserialize<Membership>(json, serializeOptions);

• 方式2：给Membership类添加特性标记，全局自动生效：

[JsonConverter(typeof(MembershipJsonConverter))]
public class Membership
{
    public Member Member { get; set; }
    public string Group { get; set; }
    public string State { get; set; }
}

注意事项 #

• 若不需要将Membership序列化回平级JSON结构，可以直接删除Write方法的实现，改为抛出NotImplementedException即可
• 代码中已默认忽略JSON中多余的未知属性，若需要严格校验可删除default分支的Skip逻辑，改为抛出异常

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