C＃Newtonsoft-根据属性名称将JSON反序列化为具体的

Question

I've got a JSON coming in that I'd like to deserialize into a class A ; one of the fields is an array of abstract class B (which has a few concrete implementations). Is it possible to deserialize the abstract-class array correctly without building a custom JsonConverter? Ideally, something native to JSON.net and not verbose, eg with TypeNameHandling.All ... but I haven't got that particular route to work.

I do not have access to the JSON at serialization-time (if I did, TypeNameHandling would work great), but only at deserialization-time.

To be concrete:

public class A  // the top-level class to deserialize
{
    public B[] arr;
    // other members...
}
public abstract class B
{
    // ...some fields...
}
public class C : B 
{
    // a concrete implementation of B
}
public class D : B 
{
    // another concrete implementation of B
}

And I receive a JSON that may look like:

{
  "arr" : [
   {
     // a C object
   },
   {
     // a D object
   }
  ]
}

I know you can effectively do something like this really cleanly with XML deserialization using the below; I'm pretty much looking for something similar in JSON.

// tells the deserializer to deserialize the object with field name "C" as a 
// class C, and field name "D" as a D
[XmlElement("C", Type = typeof(C))]
[XmlElement("D", Type = typeof(D))]
public B[] arr;

Answer 1

Since you are unable to modify the JSON to use TypeNameHandling you need to create a custom converter that examines the properties to determine which type to return. Let's say you had your derived classes looking like this for example:

public class C : B
{
    public string CProperty { get; set; }
}

public class D : B
{
    public string DProperty { get; set; }
}

You could have a custom converter class that looks like this:

public class BConverter : JsonConverter
{
    public override object ReadJson(JsonReader reader, Type type, 
        object value, JsonSerializer serializer)
    {
        JObject jobject = JObject.Load(reader);
        if (jobject.ContainsKey("CProperty"))
        {
            return jobject.ToObject<C>(serializer);
        }

        if (jobject.ContainsKey("DProperty"))
        {
            return jobject.ToObject<D>(serializer);
        }

        throw new Exception("Um, this is some other type!");
    }

    public override bool CanConvert(Type type) => type == typeof(B);
    public override bool CanWrite => false;
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) 
        => throw new NotImplementedException();
}

Now you can deserialise like this:

var result = JsonConvert.DeserializeObject<A>(json, new BConverter());