如何使用 JsonConvert.DeserializeObject 忽略空数组？

我正在使用此调用从 JSON 读取对象列表：

Rootobject userInfo = JsonConvert.DeserializeObject<Rootobject>(File.ReadAllText(strFileName));

但我有一个例外Cannot deserialize the current JSON array。如果类对象之一内的数组之一为空。只要有数据，一切就都有效。

下面是一个导致反序列化器崩溃的 JSON 示例：

这是 Venue 对象的正常数据类型：

"venue":  {
            "venue_id":  696895,
            "venue_name":  "Blackfinn Ameripub",
            "venue_slug":  "blackfinn-ameripub",
            "primary_category":  "Food",
            "parent_category_id":  "4d4b7105d754a06374d81259",
            "categories":  {
                "count":  1,
                "items":  [
                            {
                                "category_name":  "American Restaurant",
                                "category_id":  "4bf58dd8d48988d14e941735",
                                "is_primary":  true
                            }
                        ]
            },
            "is_verified":  false
        },

这是导致异常的原因，空数组：

"venue":  [

        ],

我尝试过使用JsonSerializerSettings选项包括DefaultValueHandling, NullValueHandling and MissingMemberHandling但他们似乎都没有阻止这个错误。

知道如何反序列化 JSON 并忽略数据中的任何空数组吗？我希望它能够处理任何空数组，而不仅仅是上面的对象示例Venue.

发现新问题 - 03/17/2018

您好，下面的转换器一直运行良好，但是我从中获取 json 响应的服务器引发了另一个挑战。 JSON.NET 检索此类数据没有问题：

 "toasts":  {
                "total_count":  1,
                "count":  1,
                "auth_toast":  false,
                "items":  [
                              {
                                  "uid":  3250810,
                                  "user":  {
                                               "uid":  3250810,
                                               "account_type":  "user",
                                               "venue_details":  [

                                                                 ],
                                               "brewery_details":  [

                                                                   ]
                                           },
                                  "like_id":  485242625,
                                  "like_owner":  false,
                                  "created_at":  "Wed, 07 Mar 2018 07:54:38 +0000"
                              }
                          ]
            },

特别是包含venue_details 的部分。 99% 的回复都以以下格式返回场地详细信息：

 "venue_details":  [

                   ],

但后来我突然得到了这种格式：

 "toasts":  {
                "total_count":  1,
                "count":  1,
                "auth_toast":  false,
                "items":  [
                              {
                                  "uid":  4765742,
                                  "user":  {
                                               "uid":  4765742,
                                               "account_type":  "venue",
                                               "venue_details":  {
                                                                     "venue_id":  4759473
                                                                 },
                                               "brewery_details":  [

                                                                   ],
                                               "user_link":  "https://untappd.com/venue/4759473"
                                           },
                                  "like_id":  488655942,
                                  "like_owner":  false,
                                  "created_at":  "Fri, 16 Mar 2018 16:47:10 +0000"
                              }
                          ]
            },

请注意venue_details 现在如何具有值并包含venue_id。
因此，venue_details 最终看起来像一个对象而不是数组。这最终给出了这个异常：

JsonSerializationException：无法将当前 JSON 对象（例如 {"name":"value"}）反序列化为类型 'System.Collections.Generic.List`1[System.Object]'，因为该类型需要 JSON 数组（例如 [1, 2,3]）以正确反序列化。

在提供的转换器代码中，该异常发生在旁边带有 *s 的行中：

public abstract class IgnoreUnexpectedArraysConverterBase : JsonConverter
{
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var contract = serializer.ContractResolver.ResolveContract(objectType);
        if (!(contract is JsonObjectContract))
        {
            throw new JsonSerializationException(string.Format("{0} is not a JSON object", objectType));
        }

        do
        {
            if (reader.TokenType == JsonToken.Null)
                return null;
            else if (reader.TokenType == JsonToken.Comment)
                continue;
            else if (reader.TokenType == JsonToken.StartArray)
            {
                var array = JArray.Load(reader);
                if (array.Count > 0)
                    throw new JsonSerializationException(string.Format("Array was not empty."));
                return existingValue ?? contract.DefaultCreator();
            }
            else if (reader.TokenType == JsonToken.StartObject)
            {
                // Prevent infinite recursion by using Populate()
                existingValue = existingValue ?? contract.DefaultCreator();
            *** serializer.Populate(reader, existingValue); ***
                return existingValue;

有什么想法如何添加这个额外的处理来解决返回对象而不是数组的 JSON 之间的这种翻转吗？

谢谢， 瑞克

您的问题不在于您需要忽略空数组。如果"items"数组为空，就不会有问题：

"items":  [],

相反，你的问题如下。这JSON标准 http://json.org/支持两种类型的容器：

• 数组，它是值的有序集合。数组开头为[（左括号）并以]（右括号）。值由以下分隔,（逗号）。

• 对象，是一组无序的名称/值对。一个对象开始于{（左大括号）并以}（右大括号）。

由于某种原因，服务器返回空数组代替一个空对象。如果 Json.NET 期望遇到 JSON 对象，但却遇到 JSON 数组，它将抛出Cannot deserialize the current JSON array你看到的异常。

您可能会考虑要求生成 JSON 的人修复其 JSON 输出，但与此同时，您可以使用以下转换器在反序列化对象时跳过意外的数组：

public class IgnoreUnexpectedArraysConverter<T> : IgnoreUnexpectedArraysConverterBase
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(T).IsAssignableFrom(objectType);
    }
}

public class IgnoreUnexpectedArraysConverter : IgnoreUnexpectedArraysConverterBase
{
    readonly IContractResolver resolver;

    public IgnoreUnexpectedArraysConverter(IContractResolver resolver)
    {
        if (resolver == null)
            throw new ArgumentNullException();
        this.resolver = resolver;
    }

    public override bool CanConvert(Type objectType)
    {
        if (objectType.IsPrimitive || objectType == typeof(string))
            return false;
        return resolver.ResolveContract(objectType) is JsonObjectContract;
    }
}

public abstract class IgnoreUnexpectedArraysConverterBase : JsonConverter
{
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var contract = serializer.ContractResolver.ResolveContract(objectType);
        if (!(contract is JsonObjectContract))
        {
            throw new JsonSerializationException(string.Format("{0} is not a JSON object", objectType));
        }

        do
        {
            if (reader.TokenType == JsonToken.Null)
                return null;
            else if (reader.TokenType == JsonToken.Comment)
                continue;
            else if (reader.TokenType == JsonToken.StartArray)
            {
                var array = JArray.Load(reader);
                if (array.Count > 0)
                    throw new JsonSerializationException(string.Format("Array was not empty."));
                return null;
            }
            else if (reader.TokenType == JsonToken.StartObject)
            {
                // Prevent infinite recursion by using Populate()
                existingValue = existingValue ?? contract.DefaultCreator();
                serializer.Populate(reader, existingValue);
                return existingValue;
            }
            else
            {
                throw new JsonSerializationException(string.Format("Unexpected token {0}", reader.TokenType));
            }
        }
        while (reader.Read());
        throw new JsonSerializationException("Unexpected end of JSON.");
    }

    public override bool CanWrite { get { return false; } }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

然后，如果空数组只能出现在对象图中的一处，则可以将转换器添加到模型中，如下所示：

public class Rootobject
{
    [JsonConverter(typeof(IgnoreUnexpectedArraysConverter<Venue>))]
    public Venue venue { get; set; }
}

但如果如你所说，any对象可能会被替换为空数组，您可以使用非泛型IgnoreUnexpectedArraysConverter对于所有对象类型：

var resolver = new DefaultContractResolver(); // Cache for performance
var settings = new JsonSerializerSettings
{
    ContractResolver = resolver,
    Converters = { new IgnoreUnexpectedArraysConverter(resolver) },
};
var userInfo = JsonConvert.DeserializeObject<Rootobject>(jsonString, settings);

Notes:

• 该转换器不能与TypeNameHandling https://www.newtonsoft.com/json/help/html/SerializeTypeNameHandling.htm or PreserveReferencesHandling https://www.newtonsoft.com/json/help/html/PreserveReferencesHandlingObject.htm设置。

• 转换器假定正在反序列化的对象具有默认构造函数。如果该对象有一个参数化构造函数 https://www.newtonsoft.com/json/help/html/SerializationAttributes.htm#JsonConstructorAttribute您将需要创建一个硬编码转换器来分配和填充对象。

• 如果数组不为空，转换器会抛出异常，以确保在对 JSON 结构的假设不正确时不会丢失数据。有时，服务器会写入单个对象来代替单对象数组，当存在零个、两个或多个对象时，会写入一个数组。如果您也处于这种情况（例如"items"数组）参见如何使用 JSON.net 处理同一属性的单个项目和数组 https://stackoverflow.com/q/18994685/3744182.

• 如果您希望转换器返回默认对象而不是null遇到数组时，修改如下：

  else if (reader.TokenType == JsonToken.StartArray)
  {
      var array = JArray.Load(reader);
      if (array.Count > 0)
          throw new JsonSerializationException(string.Format("Array was not empty."));
      return existingValue ?? contract.DefaultCreator();
  }
  

工作样本.Net小提琴 https://dotnetfiddle.net/FbA2R8.