那些遇到过的问题

如何在.net core 3.0中使用System.Text.Json反序列化部分json？

Gal*_*ina 4 c# json asp.net-core-3.0 system.text.json

我这里有一个 json https://api.nasa.gov/insight_weather/?api_key=DEMO_KEY&feedtype=json&ver=1.0，如下所示：

{
  "782": {
    "First_UTC": "2021-02-06T17:08:11Z",
    "Last_UTC": "2021-02-07T17:47:46Z",
    "Month_ordinal": 12,
    "Northern_season": "late winter",
    "PRE": {
      "av": 721.77,
      "ct": 113450,
      "mn": 698.8193,
      "mx": 742.2686
    },
    "Season": "winter",
    "Southern_season": "late summer",
    "WD": {
      "most_common": null
    }
  },
  "783": {
    "First_UTC": "2021-02-07T17:47:46Z",
    "Last_UTC": "2021-02-08T18:27:22Z",
    "Month_ordinal": 12,
    "Northern_season": "late winter",
    "PRE": {
      "av": 722.186,
      "ct": 107270,
      "mn": 698.7664,
      "mx": 743.1983
    },
    "Season": "winter",
    "Southern_season": "late summer",
    "WD": {
      "most_common": null
    }
  },
  "sol_keys": [ "782", "783" ],
  "validity_checks": { /* Some complex object */ }
}
Run Code Online (Sandbox Code Playgroud)

我只需要部分信息，因此我创建了以下类：

public class MarsWheather {
    [JsonPropertyName("First_UTC")]
    public DateTime FirstUTC { get; set; }
    [JsonPropertyName("Last_UTC")]
    public DateTime LastUTC { get; set; }
    [JsonPropertyName("Season")]
    [JsonConverter(typeof(JsonStringEnumConverter))]
    public Season MarsSeason { get; set; }
    [JsonPropertyName("PRE")]
    public DataDescription AtmosphericPressure { get; set; }
}

public enum Season {
    winter,
    spring,
    summer,
    autumn
}

public class DataDescription{
    [JsonPropertyName("av")]
    public double Average { get; set; }
    [JsonPropertyName("ct")]
    public double TotalCount { get; set; }
    [JsonPropertyName("mn")]
    public double Minimum { get; set; }
    [JsonPropertyName("mx")]
    public double Maximum { get; set; }
}
Run Code Online (Sandbox Code Playgroud)

问题是 NASA 的 JSON 根对象包含属性 "validity_checks"，而"sol_keys"我不需要也想跳过。在 Newton.Json 中我曾经JObject.Parse这样做过，但是在System.Text.Json我想使用

JsonSerializer.DeserializeAsync<Dictionary<string, MarsWheather>>(stream, new JsonSerializerOptions { IgnoreNullValues = true });
Run Code Online (Sandbox Code Playgroud)

不幸的是，当我这样做时，我遇到了一个例外：

public class MarsWheather {
    [JsonPropertyName("First_UTC")]
    public DateTime FirstUTC { get; set; }
    [JsonPropertyName("Last_UTC")]
    public DateTime LastUTC { get; set; }
    [JsonPropertyName("Season")]
    [JsonConverter(typeof(JsonStringEnumConverter))]
    public Season MarsSeason { get; set; }
    [JsonPropertyName("PRE")]
    public DataDescription AtmosphericPressure { get; set; }
}

public enum Season {
    winter,
    spring,
    summer,
    autumn
}

public class DataDescription{
    [JsonPropertyName("av")]
    public double Average { get; set; }
    [JsonPropertyName("ct")]
    public double TotalCount { get; set; }
    [JsonPropertyName("mn")]
    public double Minimum { get; set; }
    [JsonPropertyName("mx")]
    public double Maximum { get; set; }
}
Run Code Online (Sandbox Code Playgroud)

演示小提琴在这里。

是否可以？

dbc*_*dbc 6

JSON 根对象由某些固定键 ("sol_keys"和"validity_checks") 组成，每个固定键的值都有一些固定模式，以及任意数量的变量键（数字"782"键），它们的值都共享一个与固定键值的模式不同的公共模式：

{
  "782": {
    // Properties corresponding to your MarsWheather object
  },
  "783": {
    // Properties corresponding to your MarsWheather object
  },
  // Other variable numeric key/value pairs corresponding to KeyValuePair<string, MarsWheather>
  "sol_keys": [
    // Some array values you don't care about
  ],
  "validity_checks": {
    // Some object you don't care about
  }
}
Run Code Online (Sandbox Code Playgroud)

您只想反序列化可变键，但是当您尝试反序列化为 a 时，Dictionary<string, MarsWheather>您会得到一个异常，因为序列化程序尝试反序列化固定键值，就好像它是可变键值一样 - 但由于固定键有一个数组值当变量键具有对象值时，会引发异常。如何System.Text.Json被告知跳过已知的固定键而不是尝试反序列化它们？

如果您只想反序列化可变键并跳过固定的已知键，则需要创建一个自定义的JsonConverter. 最简单的方法是首先为你的字典创建一些根对象：

[JsonConverter(typeof(MarsWheatherRootObjectConverter))]
public class MarsWheatherRootObject
{
    public Dictionary<string, MarsWheather> MarsWheathers { get; } = new Dictionary<string, MarsWheather>();
}
Run Code Online (Sandbox Code Playgroud)

然后为其定义以下转换器，如下所示：

public class MarsWheatherRootObjectConverter : FixedAndvariablePropertyNameObjectConverter<MarsWheatherRootObject, Dictionary<string, MarsWheather>, MarsWheather>
{
    static readonly Dictionary<string, ReadFixedKeyMethod> FixedKeyReadMethods = new Dictionary<string, ReadFixedKeyMethod>(StringComparer.OrdinalIgnoreCase)
    {
        { "sol_keys", (ref Utf8JsonReader reader, MarsWheatherRootObject obj, string name, JsonSerializerOptions options) => reader.Skip() },
        { "validity_checks", (ref Utf8JsonReader reader, MarsWheatherRootObject obj, string name, JsonSerializerOptions options) => reader.Skip() },
    };

    protected override Dictionary<string, MarsWheather> GetDictionary(MarsWheatherRootObject obj) => obj.MarsWheathers;
    protected override void SetDictionary(MarsWheatherRootObject obj, Dictionary<string, MarsWheather> dictionary) => throw new RowNotInTableException();
    protected override bool TryGetFixedKeyReadMethod(string name, JsonSerializerOptions options, out ReadFixedKeyMethod method) => FixedKeyReadMethods.TryGetValue(name, out method);
    protected override IEnumerable<KeyValuePair<string, WriteFixedKeyMethod>> GetFixedKeyWriteMethods(JsonSerializerOptions options) => Enumerable.Empty<KeyValuePair<string, WriteFixedKeyMethod>>();
}

public abstract class FixedAndvariablePropertyNameObjectConverter<TObject, TDictionary, TValue> : JsonConverter<TObject> 
    where TDictionary : class, IDictionary<string, TValue>, new()
    where TObject : new()
{
    protected delegate void ReadFixedKeyMethod(ref Utf8JsonReader reader, TObject obj, string name, JsonSerializerOptions options);
    protected delegate void WriteFixedKeyMethod(Utf8JsonWriter writer, TObject value, JsonSerializerOptions options);
        
    protected abstract TDictionary GetDictionary(TObject obj);
    protected abstract void SetDictionary(TObject obj, TDictionary dictionary);
    protected abstract bool TryGetFixedKeyReadMethod(string name, JsonSerializerOptions options, out ReadFixedKeyMethod method);
    protected abstract IEnumerable<KeyValuePair<string, WriteFixedKeyMethod>> GetFixedKeyWriteMethods(JsonSerializerOptions options);
        
    public override TObject Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        if (reader.TokenType == JsonTokenType.Null)
            return (typeToConvert.IsValueType && Nullable.GetUnderlyingType(typeToConvert) == null)
                ? throw new JsonException(string.Format("Unepected token {0}", reader.TokenType))
                : default(TObject);
        if (reader.TokenType != JsonTokenType.StartObject)
            throw new JsonException(string.Format("Unepected token {0}", reader.TokenType));
        var obj = new TObject();
        var dictionary = GetDictionary(obj);
        var valueConverter = (typeof(TValue) == typeof(object) ? null : (JsonConverter<TValue>)options.GetConverter(typeof(TValue))); // Encountered a bug using the builtin ObjectConverter
        while (reader.Read())
        {
            if (reader.TokenType == JsonTokenType.PropertyName)
            {
                var name = reader.GetString();
                reader.ReadAndAssert();
                if (TryGetFixedKeyReadMethod(name, options, out var method))
                {
                    method(ref reader, obj, name, options);
                }
                else
                {
                    if (dictionary == null)
                        SetDictionary(obj, dictionary = new TDictionary());
                    dictionary.Add(name, valueConverter.ReadOrDeserialize(ref reader, typeof(TValue), options));
                }
            }
            else if (reader.TokenType == JsonTokenType.EndObject)
            {
                return obj;
            }
            else
            {
                throw new JsonException(string.Format("Unepected token {0}", reader.TokenType));
            }
        }
        throw new JsonException(); // Truncated file
    }

    public override void Write(Utf8JsonWriter writer, TObject value, JsonSerializerOptions options)
    {
        writer.WriteStartObject();
        var dictionary = GetDictionary(value);
        if (dictionary != null)
        {
            var valueConverter = (typeof(TValue) == typeof(object) ? null : (JsonConverter<TValue>)options.GetConverter(typeof(TValue))); // Encountered a bug using the builtin ObjectConverter
            foreach (var pair in dictionary)
            {
                // TODO: handle DictionaryKeyPolicy 
                writer.WritePropertyName(pair.Key);
                valueConverter.WriteOrSerialize(writer, pair.Value, typeof(TValue), options);
            }
        }
        foreach (var pair in GetFixedKeyWriteMethods(options))
        {
            writer.WritePropertyName(pair.Key);
            pair.Value(writer, value, options);
        }
        writer.WriteEndObject();
    }
}

public static partial class JsonExtensions
{
    public static void WriteOrSerialize<T>(this JsonConverter<T> converter, Utf8JsonWriter writer, T value, Type type, JsonSerializerOptions options)
    {
        if (converter != null)
            converter.Write(writer, value, options);
        else
            JsonSerializer.Serialize(writer, value, type, options);
    }

    public static T ReadOrDeserialize<T>(this JsonConverter<T> converter, ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        => converter != null ? converter.Read(ref reader, typeToConvert, options) : (T)JsonSerializer.Deserialize(ref reader, typeToConvert, options);

    public static void ReadAndAssert(this ref Utf8JsonReader reader)
    {
        if (!reader.Read())
            throw new JsonException();
    }
}
Run Code Online (Sandbox Code Playgroud)

现在您将能够反序列化MarsWheatherRootObject如下：

var root = await System.Text.Json.JsonSerializer.DeserializeAsync<MarsWheatherRootObject>(
    stream, 
    new System.Text.Json.JsonSerializerOptions 
    { 
        PropertyNameCaseInsensitive = true 
    });
Run Code Online (Sandbox Code Playgroud)

演示小提琴#1在这里。

笔记：

  • FixedAndvariablePropertyNameObjectConverter<TObject, TDictionary, TValue>提供了一个通用框架，用于序列化和反序列化具有固定和可变属性的对象。如果稍后您决定反序列化 eg "sol_keys"，您可以修改MarsWheatherRootObject如下：

    [JsonConverter(typeof(MarsWheatherRootObjectConverter))]
public class MarsWheatherRootObject
{
    public Dictionary<string, MarsWheather> MarsWheathers { get; } = new Dictionary<string, MarsWheather>();
    public List<string> SolKeys { get; set; } = new List<string>();
}
    Run Code Online (Sandbox Code Playgroud)

    转换器如下：

    public class MarsWheatherRootObjectConverter : FixedAndvariablePropertyNameObjectConverter<MarsWheatherRootObject, Dictionary<string, MarsWheather>, MarsWheather>
{
    static readonly Dictionary<string, ReadFixedKeyMethod> FixedKeyReadMethods = new(StringComparer.OrdinalIgnoreCase)
    {
        { "sol_keys", (ref Utf8JsonReader reader, MarsWheatherRootObject obj, string name, JsonSerializerOptions options) => 
            {
                obj.SolKeys = JsonSerializer.Deserialize<List<string>>(ref reader, options);
            } 
        },
        { "validity_checks", (ref Utf8JsonReader reader, MarsWheatherRootObject obj, string name, JsonSerializerOptions options) => reader.Skip() },
    };
    static readonly Dictionary<string, WriteFixedKeyMethod> FixedKeyWriteMethods = new Dictionary<string, WriteFixedKeyMethod>()
    {
        { "sol_keys", (w, v, o) => 
            {
                JsonSerializer.Serialize(w, v.SolKeys, o);
            } 
        },
    };

    protected override Dictionary<string, MarsWheather> GetDictionary(MarsWheatherRootObject obj) => obj.MarsWheathers;
    protected override void SetDictionary(MarsWheatherRootObject obj, Dictionary<string, MarsWheather> dictionary) => throw new RowNotInTableException();
    protected override bool TryGetFixedKeyReadMethod(string name, JsonSerializerOptions options, out ReadFixedKeyMethod method) => FixedKeyReadMethods.TryGetValue(name, out method);
    protected override IEnumerable<KeyValuePair<string, WriteFixedKeyMethod>> GetFixedKeyWriteMethods(JsonSerializerOptions options) => FixedKeyWriteMethods;
}
    Run Code Online (Sandbox Code Playgroud)

    演示小提琴#2在这里。

归档时间：

查看次数：

3063 次

最近记录：

4 年，9 月 前
相关归档
Microsoft.Jet.OLEDB.4.0'提供程序未在本地计算机上注册 184
你怎么找到这个月的最后一天？ 91
将数字转换为单词C# 61
从开关块中断开foreach循环 57
什么事件表明UserControl被销毁？ 38
有没有办法在elasticsearch服务器中导入json文件(包含100个文档). 32
纠正PHP代码以检查变量是否存在 21
使用$ skip与SharePoint 2013 REST API 13
使用自定义 json 响应进行 Laravel 验证 9
我在Eclipse中的.json文件中得到了"XX:YY上的预期名称"错误.怎么了？ 7
难疑归档
如何检查字符串是否包含Bash中的子字符串 2332
什么是TypeScript,为什么我会用它代替JavaScript？ 1637
如何使用对象作为成员循环一个普通的JavaScript对象？ 1521
在JavaScript对象数组中按id查找对象 1435
检查Ruby中的数组中是否存在值 1258
如何使用CSS设置<select>下拉列表的样式？ 1258
SQL仅选择列上具有最大值的行 1142
servlet如何工作？实例化,会话,共享变量和多线程 1105
什么是首选的Bash shebang？ 1051
什么是"Linting"？ 1044