Deserializing JSON with varying schemas

Question

I use JSON.Net with .NET 4.7.

In an API I call, I can get two kinds of error jsons for the same call seemingly randomly :(.

Error Type 1:

{
   "Code": 0,
   "Msg": ["Some Warning"]
}

Error Type 2:

{
    "Code": 0,
    "Msg": [
          {"Error": 5 },
          {"Error": 6 }
    ]
}

As you can see, the Msg changes its structure. I'd like to have a common POCO to deserialize into, but how when the Msg changes?

JsonConvert.DeserializeObject<MyCommonPoco>(theJson);

The second JSON is not well-formed. Try uploading to https://jsonlint.com/ and you will get `Error: Parse error on line 4:`. Can you please provide valid JSON samples? — dbc, Aug 08 '18 at 21:56
My bad in typing. The question is more about changing schemas — Ian Vink, Aug 08 '18 at 22:01
You'll need a custom creation converter: https://www.newtonsoft.com/json/help/html/CustomCreationConverter.htm — Christoph Lütjen, Aug 08 '18 at 22:02
You can make the Msg property a generic list, and provide a method in the POCO to get the real type of list item. Or write your own converter, like @ChristophLütjen said — CSakura, Aug 08 '18 at 22:05
`{"Error", 5 }` is not well-formed JSON. Should that be `{"Error": 5 }`? — dbc, Aug 08 '18 at 22:05
You'll need to set the type of `Msg` to be A] `Object`, B] `dynamic`, or C] a generic type. — Abion47, Aug 08 '18 at 22:09

poke · Accepted Answer · 2018-08-09T07:57:45.693

You can write a custom JsonConverter that handles different types. You could for example have the following JSON:

{
    "Code": 0,
    "Msg": [
        "A single string",
        { "Message": "An object with a message" },
        { "Message": "An object with a message and a code", "Code": 5 },
        { "Code": 5 }
    ]
}

In this example, the Msg array can contain primitive strings, or a complex object. And that object can contain a Message, a Code, or both.

You would choose the most common data structure for this, one that is able to represent all that information. That means for example that you will have to wrap that primitive string into a compatible object.

public class Error
{
    public int Code { get; set; }
    public ErrorMessage[] Msg { get; set; }
}

public class ErrorMessage
{
    public string Message { get; set; }
    public int? Code { get; set; }
}

You can then use a custom

And then, with a custom JsonConverter, you could parse the above JSON:

public class ErrorMessageConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
        => objectType == typeof(ErrorMessage);

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        // handle the primitive string
        if (reader.TokenType == JsonToken.String)
            return new ErrorMessage { Message = (string)reader.Value };

        // handle a complex object; just assume that it is an `ErrorMessage` here
        else if (reader.TokenType == JsonToken.StartObject)
            return JObject.Load(reader).ToObject<ErrorMessage>();

        throw new NotSupportedException();
    }

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

This would be one way to use that converter:

// the single quotes are just here to make it more readable; JSON.NET support this
// although it isn’t valid JSON
var json = @"{
    'Code': 0,
    'Msg': [
        'A single string',
        { 'Message': 'An object with a message' },
        { 'Message': 'An object with a message and a code', 'Code': 5 },
        { 'Code': 5 }
    ]
}";

var settings = new JsonSerializerSettings()
settings.Converters.Add(new ErrorMessageConverter());

var result = JsonConvert.DeserializeObject<Error>(json, settings);

Successfully parsed result

Deserializing JSON with varying schemas

1 Answers1