Question

Suppose I have the following class hierarchy:

public abstract class Organization
{
    /* properties related to all organizations */
}

public sealed class Company : Organization
{
     /* properties related to companies */
} 

public sealed class NonProfitOrganization : Organization
{
     /* properties related to non profit organizations */
}

Is it possible to have json.net use property (say “type” or “discriminator”) to determine which type the object when it deserializes the organization? For example, the following should deserialize an instance of Company.

{
   "type": "company"
   /* other properties related to companies */
}

And the following should deserialize an instance of NonProfitOrganization.

{
   "type": "non-profit"
   /* other properties related to non profit */
}

When I call the following:

Organization organization = JsonConvert.DeserializeObject<Organization>(payload);

where payload is the above JSON snippets. I had a look at setting the “TypeNameHandling” on properties or classes but it serializes the whole .NET type, which isn’t “portable” between the client and server when the classes are defined in different namespaces and assemblies.

I’d rather define the type is a neutral manner which clients written in any language can use to determine the actual type of the object type being serialized.

Answer 1

In case you are still looking, here is an example: http://james.newtonking.com/archive/2011/11/19/json-net-4-0-release-4-bug-fixes.aspx

This will allow you to create a table based mapping:

public class TypeNameSerializationBinder : SerializationBinder
{
    public TypeNameSerializationBinder(Dictionary<Type, string> typeNames = null)
    {
        if (typeNames != null)
        {
            foreach (var typeName in typeNames)
            {
                Map(typeName.Key, typeName.Value);
            }
        }
    }

    readonly Dictionary<Type, string> typeToName = new Dictionary<Type, string>();
    readonly Dictionary<string, Type> nameToType = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase);

    public void Map(Type type, string name)
    {
        this.typeToName.Add(type, name);
        this.nameToType.Add(name, type);
    }

    public override void BindToName(Type serializedType, out string assemblyName, out string typeName)
    {
        var name = typeToName.Get(serializedType);
        if (name != null)
        {
            assemblyName = null;
            typeName = name;
        }
        else
        {
            assemblyName = serializedType.Assembly.FullName;
            typeName = serializedType.FullName;                
        }
    }

    public override Type BindToType(string assemblyName, string typeName)
    {
        if (assemblyName == null)
        {
            var type = this.nameToType.Get(typeName);
            if (type != null)
            {
                return type;
            }
        }
        return Type.GetType(string.Format("{0}, {1}", typeName, assemblyName), true);
    }
}

The code has a slight defect in that if a type name mapping is attempted where the type is unique but the name is already used, the Map method will throw an exception after the type-to-name mapping is already added leaving the table in an inconsistent state.