c# Newtonsoft.json DeserializeObject Issue - json.net

Question

Hopefully someone can help me with my issue.
I'm working with a 3rd party API that, depending on the configuration of the product in the backend, will return a different structure of JSON as the response.
I've included JSON samples showing the different outcomes depending on the product. There are 3 scenarios for the FreeGifts section of the product:
Has 2 or more free gifts.
Has 1 free gifts.
Has no free gifts
Scenario 1
{
"FreeGifts": [{
"FreeGift": [{
"SKU": "BOWS-SMALL-ALFIE"
},
{
"SKU": "BOWS-LARGE-ALONZO"
},
{
"SKU": "BOWS-LARGE-CLANCY"
},
{
"SKU": "BOWS-SMALL-ALVIN"
},
{
"SKU": "BOWS-SMALL-CLARK"
}
]
}]
}
Scenario 2
{
"FreeGifts": [{
"FreeGift": {
"SKU": "BOWS-SMALL-ALVIN"
}
}]
}
Scenario 3
{
"FreeGifts": [
""
]
}
Sites like http://json2csharp.com/ and https://jsonutils.com/ provide me with 3 different class definitions depending on the scenario.
If I had only 1 of these in the structure I could probably deal with it but I have around 7 or 8. It's impossible for me to cater for it.
I'm completely stumped as to how I get Newtonsoft.json to work with the ambiguity that the API produces.
Do I need to go back to the provider and ask them if they can change it?!?

Answer 1

You can use SingleOrArrayConverter<FreeGift> from this answer to How to handle both a single item and an array for the same property using JSON.net by Brian Rogers along with TolerantObjectCollectionConverter<FreeGifts> from this answer to How can I ignore a blank array inside an array of JSON objects while deserializing? to successfully deserialize all 3 JSON variants. To do so, define your model and apply the appropriate JSON converter as follows:
public class Root
{
[JsonConverter(typeof(TolerantObjectCollectionConverter<FreeGifts>))]
public List<FreeGifts> FreeGifts { get; set; }
}
public class FreeGifts
{
[JsonConverter(typeof(SingleOrArrayConverter<FreeGift>))]
public List<FreeGift> FreeGift { get; set; }
}
public class FreeGift
{
public string SKU { get; set; }
}
class SingleOrArrayConverter<T> : JsonConverter
{
// Taken from the answer to
// https://stackoverflow.com/questions/18994685/how-to-handle-both-a-single-item-and-an-array-for-the-same-property-using-json-n
// https://stackoverflow.com/a/18997172
// by Brian Rogers
public override bool CanConvert(Type objectType)
{
return (objectType == typeof(List<T>));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var tokenType = reader.SkipComments().TokenType;
if (tokenType == JsonToken.Null)
return null;
var list = existingValue as List<T> ?? new List<T>();
if (tokenType == JsonToken.StartArray)
{
serializer.Populate(reader, list);
}
else
{
list.Add(serializer.Deserialize<T>(reader));
}
return list;
}
public override bool CanWrite { get { return false; } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
throw new NotImplementedException();
}
}
public class TolerantObjectCollectionConverter<TItem> : JsonConverter
{
// Taken from the answer to
// https://stackoverflow.com/questions/49030516/how-can-i-ignore-a-blank-array-inside-an-array-of-json-objects-while-deserializi
// https://stackoverflow.com/a/49078620/
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;
}
}
Notes:
[JsonConverter(typeof(TolerantObjectCollectionConverter<FreeGifts>))] handles the fact that the upper-level "FreeGifts": [] array may sometimes contain an unwanted string value. The value is simply skipped.
[JsonConverter(typeof(SingleOrArrayConverter<FreeGift>))] handles the fact that the "FreeGift" property value may sometimes be either a single object or an array of objects.
You could combine the two converters in situations where a property value might be an array with invalid items or a single object not contained in an array. However, this isn't the case in the three JSON examples shown.
Sample working .Net fiddle.