Question

我遇到了一个不寻常的问题。这可能不是一个非常现实的场景，但这就是我自己的意思，所以请耐心等待。

我有一个返回Json的API，我正在使用Json.NET来处理Json响应。问题是API可以返回许多内容，我必须能够通过以下方式反序列化响应：

API可以返回单个Json对象。在这种情况下，我必须将其反序列化为ExpandoObject并将其放入List<dynamic>。
API可以返回null和undefined等，在这种情况下我必须返回一个空列表。
API可以返回单个原始值，如Json字符串或Json浮点数。在这种情况下，我必须将其反序列化为适当的.NET类型，将其放在List<dynamic>中并返回。
API可以返回Json数组。在这种情况下，我必须将数组反序列化为List<dynamic>：
- 数组中的元素可以是Json对象，在这种情况下，我必须再次将它们反序列化为ExpandoObject，并将它们放在列表中。
- 元素也可以是原始值。在这种情况下，我必须将它们反序列化为正确的.NET类型并将它们放在列表中。

根据我的研究，这是我到目前为止所得到的：

protected IQueryable<dynamic> TestMethod(string r)
{
  using (StringReader sr = new StringReader(r))
  using (JsonTextReader reader = new JsonTextReader(sr))
  {
    if (!reader.Read())
    {
      return new List<ExpandoObject>().AsQueryable();
    }

    switch (reader.TokenType)
    {
      case JsonToken.None:
      case JsonToken.Null:
      case JsonToken.Undefined:
         return new List<ExpandoObject>().AsQueryable();
      case JsonToken.StartArray:
         return JsonConvert.DeserializeObject<List<ExpandoObject>>(r).AsQueryable();
      case JsonToken.StartObject:
         return DeserializeAs<ExpandoObject>(r);
      case JsonToken.Integer:
         return DeserializeAs<long>(r);
      case JsonToken.Float:
         return DeserializeAs<double>(r);
      // other Json primitives deserialized here
      case JsonToken.StartConstructor:
      // listing other not processed tokens
      default:
         throw new InvalidOperationException($"Token {reader.TokenType} cannot be the first token in the result");
    }
  }
}

private IQueryable<dynamic> DeserializeAs<T>(string r)
{
   T instance = JsonConvert.DeserializeObject<T>(r);
   return new List<dynamic>() { instance }.AsQueryable();
}

问题在于最后一个要点。在switch-case中，当反序列化器遇到StartArray标记时，它会尝试将json反序列化为List<ExpandoObject>，但如果数组包含整数，则无法将它们反序列化为ExpandoObject。< / p>

任何人都可以给我一个简单的解决方案来支持两种情况：Json对象数组到List<ExpandoObject>和Json基元数组到各自的列表？

Answer 1

由于Json.NET是在MIT license下获得许可的，因此您可以调整ExpandoObjectConverter的逻辑以满足您的需求，并创建以下方法：

public static class JsonExtensions
{
    public static IQueryable<object> ReadJsonAsDynamicQueryable(string json, JsonSerializerSettings settings = null)
    {
        var serializer = JsonSerializer.CreateDefault(settings);
        using (StringReader sr = new StringReader(json))
        using (JsonTextReader reader = new JsonTextReader(sr))
        {
            var root = JsonExtensions.ReadJsonAsDynamicQueryable(reader, serializer);
            return root;
        }
    }

    public static IQueryable<dynamic> ReadJsonAsDynamicQueryable(JsonReader reader, JsonSerializer serializer)
    {
        dynamic obj;

        if (!TryReadJsonAsDynamic(reader, serializer, out obj) || obj == null)
            return Enumerable.Empty<dynamic>().AsQueryable();

        var list = obj as IList<dynamic> ?? new [] { obj };

        return list.AsQueryable();
    }

    public static bool TryReadJsonAsDynamic(JsonReader reader, JsonSerializer serializer, out dynamic obj)
    {
        // Adapted from:
        // https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/Converters/ExpandoObjectConverter.cs
        // License:
        // https://github.com/JamesNK/Newtonsoft.Json/blob/master/LICENSE.md

        if (reader.TokenType == JsonToken.None)
            if (!reader.Read())
            {
                obj = null;
                return false;
            }

        switch (reader.TokenType)
        {
            case JsonToken.StartArray:
                var list = new List<dynamic>();
                ReadList(reader,
                    (r) =>
                    {
                        dynamic item;
                        if (TryReadJsonAsDynamic(reader, serializer, out item))
                            list.Add(item);
                    });
                obj = list;
                return true;

            case JsonToken.StartObject:
                obj = serializer.Deserialize<ExpandoObject>(reader);
                return true;

            default:
                if (reader.TokenType.IsPrimitiveToken())
                {
                    obj = reader.Value;
                    return true;
                }
                else
                {
                    throw new JsonSerializationException("Unknown token: " + reader.TokenType);
                }
        }
    }

    static void ReadList(this JsonReader reader, Action<JsonReader> readValue)
    {
        while (reader.Read())
        {
            switch (reader.TokenType)
            {
                case JsonToken.Comment:
                    break;
                default:
                    readValue(reader);
                    break;
                case JsonToken.EndArray:
                    return;
            }
        }
        throw new JsonSerializationException("Unexpected end when reading List.");
    }

    public static bool IsPrimitiveToken(this JsonToken token)
    {
        switch (token)
        {
            case JsonToken.Integer:
            case JsonToken.Float:
            case JsonToken.String:
            case JsonToken.Boolean:
            case JsonToken.Undefined:
            case JsonToken.Null:
            case JsonToken.Date:
            case JsonToken.Bytes:
                return true;
            default:
                return false;
        }
    }
}

然后使用它：

protected IQueryable<dynamic> TestMethod(string r)
{
    return JsonExtensions.ReadJsonAsDynamicQueryable(r);
}

或者，您可以在您创建的ReadJson()的custom JsonConverter方法中拨打ReadJsonAsDynamicQueryable。

示例fiddle。

将任意json响应转换为“事物”列表

1 个答案: