How to deserialize a JSON array of elements with different types and varying number of elements?

Question

I am dealing with a JSON array, where each element is of a different type, indicated by a type attribute. There can be more than one element of the same type, and the number of elements is not known beforehand. That is:

[
  {
    'abc': '0',
    'type': 'a'
  },
  {
    'cde': '10',
    'type: 'b'
  },
  {
    'abc': '20'
    'type': 'a'
  }
]

I need to deserialize such an array into a List<A> and List<B>.

I looked into Json.NET documentation but I am not sure what would be a good strategy or feature to use for this task. Any pointers would be appreciated.

It looks like this was incorrectly marked as duplicate? The referenced duplicate question has nothing to do with an array of objects with varying type. — Neil, Jan 03 '19 at 18:00
@Neil, I agree. I did change the title of the question to make it more clear, I hope that helps. — user11081980, Jan 03 '19 at 18:01
Why not deserialize into a `List`? If you did that it would be a duplicate of [How to implement custom JsonConverter in JSON.NET to deserialize a List of base class objects?](https://stackoverflow.com/q/8030538/3744182) and/or [Deserializing polymorphic json classes without type information using json.net](https://stackoverflow.com/q/19307752/3744182). Having to deserialize into two top-level lists means two passes through the JSON. — dbc, Jan 03 '19 at 18:05
Or if the `'type'` property corresponds to the .Net type directly, you might use [Json.Net Serialization of Type with Polymorphic Child Object](https://stackoverflow.com/a/29531372/3744182). — dbc, Jan 03 '19 at 18:09

score 1 · Answer 1 · answered Jan 03 '19 at 18:16

Assuming your types are all known before hand you can deserialize all elements to JObject and use linq to separate the initial array into multiple lists.

Instead of using List<JObject>, you could declare an abstract base type as dbc suggests then implement a custom JsonConverter.

In either case if you want separate lists of each sub type you will need to iterate over your initial array converting the super type to sub type.

Define your types:

class A
{
    public int abc { get; set; }
}

class B
{
    public int cde { get; set; }
}

Then deserialize your base array, and use linq to split into two separate lists.

string json = @"[
    {
    'abc': '0',
    'type': 'a'
    },
    {
    'cde': '10',
    'type': 'b'
    },
    {
    'abc': '20',
    'type': 'a'
    }
]";

List<JObject> objs = JsonConvert.DeserializeObject<List<JObject>>(json);

List<A> objectsA = objs.Where(d => d["type"].ToString() == "a").Select(d => d.ToObject<A>()).ToList();
List<B> objectsB = objs.Where(d => d["type"].ToString() == "b").Select(d => d.ToObject<B>()).ToList();

score 0 · Answer 2 · answered Jan 03 '19 at 20:29

Re-elaborating answers given here and here, and using a base class as stated by dbc, you can obtain the required result.

First, define the types:

class BaseClass
{
    [JsonProperty("type")]
    public string EntityType
    { get; set; }
}

class A : BaseClass
{
    public int abc { get; set; }
}

class B : BaseClass
{
    public int cde { get; set; }
}

Then, define the custom creation converter:

class BaseClassConverter : JsonCreationConverter<BaseClass>
{
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        // Implement this if you need to serialize the object too
        throw new NotImplementedException();
    }

    protected override BaseClass Create(Type objectType, JObject jObject)
    {
        if (jObject["type"].Value<string>() == "a")
        {
            return new A();
        }
        else
        {
            return new B();
        }
    }
}

public abstract class JsonCreationConverter<T> : JsonConverter
{
    /// <summary>
    /// Create an instance of objectType, based properties in the JSON object
    /// </summary>
    /// <param name="objectType">type of object expected</param>
    /// <param name="jObject">
    /// contents of JSON object that will be deserialized
    /// </param>
    /// <returns></returns>
    protected abstract T Create(Type objectType, JObject jObject);

    public override bool CanConvert(Type objectType)
    {
        return typeof(T).IsAssignableFrom(objectType);
    }

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

    public override object ReadJson(JsonReader reader,
                                    Type objectType,
                                     object existingValue,
                                     JsonSerializer serializer)
    {
        // Load JObject from stream
        JObject jObject = JObject.Load(reader);

        // Create target object based on JObject
        T target = Create(objectType, jObject);

        // Populate the object properties
        serializer.Populate(jObject.CreateReader(), target);

        return target;
    }
}

Finally, you deserialize your json and obtain the wanted lists:

string json = @"[
        {
        'abc': '0',
        'type': 'a'
        },
        {
        'cde': '10',
        'type': 'b'
        },
        {
        'abc': '20',
        'type': 'a'
        }
    ]";


    List<BaseClass> objects = JsonConvert.DeserializeObject<List<BaseClass>>(json, new BaseClassConverter());
    List<A> aObjects = objects.Where(t => t.GetType() == typeof(A)).Select(o => (A)o).ToList();
    List<B> bObjects = objects.Where(t => t.GetType() == typeof(B)).Select(o => (B)o).ToList();

If and only if the type attribute is the fully qualified name of your type, you can use this in the custom creation converter:

protected override BaseClass Create(Type objectType, JObject jObject)
{
     string type = jObject["type"].Value<string>();
     return (BaseClass)Activator.CreateInstance(Type.GetType(type));
}

How to deserialize a JSON array of elements with different types and varying number of elements?

2 Answers2

Linked