How can I ignore a blank array inside an array of JSON objects while deserializing?

Question

I am deserializing JSON using Json.NET. How can I ignore a blank array that unexpectedly occurs inside an array of objects during deserialization?

I have tested the following JSON from a third party on this website http://json.parser.online.fr/ which confirm that it is well-formed:

{
  "total_events": 3551574,
  "json.appID": [
    {
      "count": 3551024,
      "term": 1
    },
    {
      "count": 256,
      "term": 2
    },
    []                /* <----- I need to ignore this empty array */
  ],
  "unique_field_count": 2
}

I would like to deserialize it to the following model:

public class RootObject
{
    [JsonProperty("total_events")]
    public int TotalEvents { get; set; }

    [JsonProperty("json.appID")]
    public List<JsonAppID> AppIds { get; set; }

    [JsonProperty("unique_field_count")]
    public int UniqueFieldCount { get; set; }
}

public class JsonAppID
{
    [JsonProperty(PropertyName = "count")]
    public int Count { get; set; }

    [JsonProperty(PropertyName = "term")]
    public string Term { get; set; }
}

But when I try, I get the following exception:

Newtonsoft.Json.JsonSerializationException: Cannot deserialize the current JSON array (e.g. [1,2,3]) into type 'JsonAppID' because the type requires a JSON object (e.g. {"name":"value"}) to deserialize correctly.
To fix this error either change the JSON to a JSON object (e.g. {"name":"value"}) or change the deserialized type to an array or a type that implements a collection interface (e.g. ICollection, IList) like List that can be deserialized from a JSON array. JsonArrayAttribute can also be added to the type to force it to deserialize from a JSON array.
Path '['json.appID'][2]', line 12, position 6.

How can I ignore the unneeded empty array inside the "json.appID" array and successfully deserialize my model?

that doesn't sound like a valid json – Franck Feb 28 '18 at 13:18 — Franck, Feb 28 '18 at 13:18

dbc · Accepted Answer · 2018-03-06T07:46:02.637

Json.NET will throw an exception when the expected JSON value type (object, array or primitive) does not match the observed type. In your case your JsonAppID type corresponds to a JSON object - an unordered set of name/value pairs which begins with { (left brace) and ends with } (right brace). When an array is encountered instead the exception you see is thrown.

If you would prefer to silently skip invalid value types in an array of objects, you could introduce a custom JsonConverter for ICollection<T> which does just that:

public class TolerantObjectCollectionConverter<TItem> : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return !objectType.IsArray && objectType != typeof(string) && typeof(ICollection<TItem>).IsAssignableFrom(objectType);
    }

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

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

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        // Get contract information
        var contract = serializer.ContractResolver.ResolveContract(objectType) as JsonArrayContract;
        if (contract == null || contract.IsMultidimensionalArray || objectType.IsArray)
            throw new JsonSerializationException(string.Format("Invalid array contract for {0}", objectType));

        // Process the first token
        var tokenType = reader.SkipComments().TokenType;
        if (tokenType == JsonToken.Null)
            return null;
        if (tokenType != JsonToken.StartArray)
            throw new JsonSerializationException(string.Format("Expected {0}, encountered {1} at path {2}", JsonToken.StartArray, reader.TokenType, reader.Path));

        // Allocate the collection
        var collection = existingValue as ICollection<TItem> ?? (ICollection<TItem>)contract.DefaultCreator();

        // Process the collection items
        while (reader.Read())
        {
            switch (reader.TokenType)
            {
                case JsonToken.EndArray:
                    return collection;

                case JsonToken.StartObject:
                case JsonToken.Null:
                    collection.Add(serializer.Deserialize<TItem>(reader));
                    break;

                default:
                    reader.Skip();
                    break;
            }
        }
        // Should not come here.
        throw new JsonSerializationException("Unclosed array at path: " + reader.Path);
    }
}

public static partial class JsonExtensions
{
    public static JsonReader SkipComments(this JsonReader reader)
    {
        while (reader.TokenType == JsonToken.Comment && reader.Read())
            ;
        return reader;
    }
}

Then apply it to your data model as follows:

public class JsonAppID
{
    [JsonProperty(PropertyName = "count")]
    public int Count { get; set; }

    [JsonProperty(PropertyName = "term")]
    public string Term { get; set; }
}

public class RootObject
{
    [JsonProperty("total_events")]
    public int TotalEvents { get; set; }

    [JsonProperty("json.appID")]
    [JsonConverter(typeof(TolerantObjectCollectionConverter<JsonAppID>))]
    public List<JsonAppID> AppIds { get; set; }

    [JsonProperty("unique_field_count")]
    public int UniqueFieldCount { get; set; }
}

Sample working .Net fiddle.

How can I ignore a blank array inside an array of JSON objects while deserializing?

1 Answers1

Linked