C# - 将嵌套的 json 反序列化为嵌套的 Dictionary<string, object>

Question

我正在使用 .net core 3.1 和库 System.Text.Json

如何将嵌套的 json 对象反序列化为 Dictionary<string, object>，但期望基于 json 属性类型我将获得正确的 C# 类型：

String -> string
Number -> int/double
Object -> Dictionary<string, object>

默认情况下 - 如果我尝试反序列化为 Dictionary<string, object> - 基本上每个对象都是一个 JsonElement。我希望它是如上所述的类型。

知道如何实现吗？

Answer 1

为了将自由格式的 JSON 反序列化为 .Net 原始类型而不是JsonElement对象，您需要编写一个customJsonConverter，因为System.Text.Json开箱即用没有提供此类功能。

一种这样的转换器如下：

public class ObjectAsPrimitiveConverter : JsonConverter<object>
{
    FloatFormat FloatFormat { get; init; }
    UnknownNumberFormat UnknownNumberFormat { get; init; }
    ObjectFormat ObjectFormat { get; init; }

    public ObjectAsPrimitiveConverter() : this(FloatFormat.Double, UnknownNumberFormat.Error, ObjectFormat.Expando) { }
    public ObjectAsPrimitiveConverter(FloatFormat floatFormat, UnknownNumberFormat unknownNumberFormat, ObjectFormat objectFormat)
    {
        this.FloatFormat = floatFormat;
        this.UnknownNumberFormat = unknownNumberFormat;
        this.ObjectFormat = objectFormat;
    }
    
    public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
    {
        if (value.GetType() == typeof(object))
        {
            writer.WriteStartObject();
            writer.WriteEndObject();
        }
        else
        {
            JsonSerializer.Serialize(writer, value, value.GetType(), options);
        }
    }
    
    public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        switch (reader.TokenType)
        {
            case JsonTokenType.Null:
                return null;
            case JsonTokenType.False:
                return false;
            case JsonTokenType.True:
                return true;
            case JsonTokenType.String:
                return reader.GetString();
            case JsonTokenType.Number:
            {
                if (reader.TryGetInt32(out var i))
                    return i;
                if (reader.TryGetInt64(out var l))
                    return l;
                // BigInteger could be added here.
                if (FloatFormat == FloatFormat.Decimal && reader.TryGetDecimal(out var m))
                    return m;
                else if (FloatFormat == FloatFormat.Double && reader.TryGetDouble(out var d))
                    return d;
                using var doc = JsonDocument.ParseValue(ref reader);
                if (UnknownNumberFormat == UnknownNumberFormat.JsonElement)
                    return doc.RootElement.Clone();
                throw new JsonException(string.Format("Cannot parse number {0}", doc.RootElement.ToString()));
            }
            case JsonTokenType.StartArray:
            {
                var list = new List<object>();
                while (reader.Read())
                {
                    switch (reader.TokenType)
                    {
                        default:
                            list.Add(Read(ref reader, typeof(object), options));
                            break;
                        case JsonTokenType.EndArray:
                            return list;
                    }
                }
                throw new JsonException();
            }
            case JsonTokenType.StartObject:
                var dict = CreateDictionary();
                while (reader.Read())
                {
                    switch (reader.TokenType)
                    {
                        case JsonTokenType.EndObject:
                            return dict;
                        case JsonTokenType.PropertyName:
                            var key = reader.GetString();
                            reader.Read();
                            dict.Add(key, Read(ref reader, typeof(object), options));
                            break;
                        default:
                            throw new JsonException();
                    }
                }
                throw new JsonException();
            default:
                throw new JsonException(string.Format("Unknown token {0}", reader.TokenType));
        }
    }
    
    protected virtual IDictionary<string, object> CreateDictionary() => 
        ObjectFormat == ObjectFormat.Expando ? new ExpandoObject() : new Dictionary<string, object>();
}

public enum FloatFormat
{
    Double,
    Decimal,
}

public enum UnknownNumberFormat
{
    Error,
    JsonElement,
}

public enum ObjectFormat
{
    Expando,
    Dictionary,
}

并使用它，反序列化为object（或dynamic如果配置为使用ExpandoObject），如下所示：

var options = new JsonSerializerOptions
{
    Converters = { new ObjectAsPrimitiveConverter(floatFormat : FloatFormat.Double, unknownNumberFormat : UnknownNumberFormat.Error, objectFormat : ObjectFormat.Expando) },
    WriteIndented = true,
};
dynamic d = JsonSerializer.Deserialize<dynamic>(json, options);

笔记：

• JSON 允许任意精度和大小的数字，而 .Net 原始数字类型则不允许。在某些 JSON 数字无法解析为 .Net 原始类型的情况下，转换器提供了JsonElement为数字返回 a或抛出异常的选项。

  转换器可以扩展为尝试将不支持的数字反序列化为BigInteger.

• 您可以将转换器配置为使用double或decimal用于浮点数，和/Dictionary<string, object>或ExpandoObject用于 JSON 对象。

演示小提琴在这里。