JSON serialization of array with polymorphic objects

by

Json.NET has a neat solution for this. There is a setting that intelligently adds type information – declare it like this:

new JsonSerializer { TypeNameHandling = TypeNameHandling.Auto };

This will determine whether type embedding is required and add it where necessary. Lets say I had the following classes:

public class Message
{
    public object Body { get; set; }
}

public class Person
{
    public string Name { get; set; }
}

public class Manager : Person
{

}

public class Department
{
    private List<Person> _employees = new List<Person>();
    public List<Person> Employees { get { return _employees; } }
}

Notice the Message Body is of type object, and that Manager subclasses Person. If I serialize a Message with a Department Body that has a single Manager I get this:

{
    "Body":
    {
        "$type":"Department, MyAssembly",
        "Employees":[
            {
                "$type":"Manager, MyAssembly",
                "Name":"Tim"
            }]
    }
}

Notice how it’s added the $type property to describe the Department and Manager types. If I now add a Person to the Employees list and change the Message Body to be of type Department like this:

public class Message
{
    public Department Body { get; set; }
}

then the Body type annotation is no longer needed and the new Person is not annotated – absence of annotation assumes the element instance is of the declared array type. The serialized format becomes:

{
    "Body":
    {
        "Employees":[
            {
                "$type":"Manager, MyAssembly",
                "Name":"Tim"
            },
            {
                "Name":"James"
            }]
    }
}

This is an efficient approach – type annotation is only added where required. While this is .NET specific, the approach is simple enough to handle that deserializers/message types on other platforms should be fairly easily extended to handle this.

I’d be reticent about using this in a public API though, as it is non-standard. In that case you’d want to avoid polymorphism, and make versioning and type information very explicit properties in the message.

More Related Contents:

  1. How to localize when JSON-serializing?
  2. How to deserialize a JObject to .NET object
  3. Does .NET 4 have a built-in JSON serializer/deserializer?
  4. replace WCF built-in JavascriptSerializer with Newtonsoft Json.Net json serializer
  5. How to remove k__BackingField from json when Deserialize
  6. What’s the best way to jSON serialize a .NET DataTable in WCF?
  7. Deserialize JSON into C# dynamic object?
  8. How to deserialize an array of values with a fixed schema to a strongly typed data class?
  9. Getting ServiceStack to retain type information
  10. Detect if deserialized object is missing a field with the JsonConvert class in Json.NET
  11. Can Json.NET serialize / deserialize to / from a stream?
  12. Using Json.NET converters to deserialize properties
  13. What is the correct way to make a custom .NET Exception serializable?
  14. How to serialize/deserialize a custom collection with additional properties using Json.Net
  15. Custom Deserialization using Json.NET
  16. Deserializing empty xml attribute value into nullable int property using XmlSerializer
  17. Ensuring json keys are lowercase in .NET
  18. C# automatic property deserialization of JSON
  19. Cannot deserialize JSON array into type – Json.NET
  20. RestSharp serialization to JSON, object is not using SerializeAs attribute as expected
  21. DataContractSerializer vs XmlSerializer: Pros and Cons of each serializer
  22. Ignoring a field during .NET JSON serialization; similar to [XmlIgnore]?
  23. “Type not expected”, using DataContractSerializer – but it’s just a simple class, no funny stuff?
  24. Any way to make DataContractJsonSerializer serialize Dictionaries properly?
  25. Can I serialize Anonymous Types as xml?
  26. Get Raw json string in Newtonsoft.Json Library
  27. ResponseFormat.Json returns xml [duplicate]
  28. How to serialize or deserialize a JSON Object to a certain depth in C#?
  29. Deserializing JSON into an object with Json.NET
  30. Using .Net what limitations (if any) are there in using the XmlSerializer?

Leave a Comment