using System;

using System.Collections.Generic;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Serialization;

​

using Xunit;

​

public class Program

{

    public static void Main()

    {

        JsonTypeConverterProblem problem = new JsonTypeConverterProblem();

        problem.ShowSerializationBug();

        problem.DeserializationWorks();

    }

}

​

public class A

{

    public string Id { get; set; }

    public A Child { get; set; }

}

​

public class B : A {}

​

public class C : A {}

​

/// <summary>

/// Shows the problem I'm having serializing classes with Json.

/// </summary>

public sealed class JsonTypeConverterProblem

{

    [Fact]

    public void ShowSerializationBug()

    {

        A a = new B()

              {

                  Id = "foo",

                  Child = new C() { Id = "bar" }

              };

        JsonSerializerSettings jsonSettings = new JsonSerializerSettings();

        jsonSettings.ContractResolver = new TypeHintContractResolver();

        string json = JsonConvert.SerializeObject(a, Formatting.Indented, jsonSettings);

        Console.WriteLine(json);

​

        Assert.Contains(@"""Target"": ""B""", json);

        Assert.Contains(@"""Is"": ""C""", json);

    }

​

    [Fact]

    public void DeserializationWorks()

    {

        string json =

@"{

  ""Target"": ""B"",

  ""Id"": ""foo"",

  ""Child"": { 

        ""Is"": ""C"",

        ""Id"": ""bar"",

    }

}";

​

        JsonSerializerSettings jsonSettings = new JsonSerializerSettings();

        jsonSettings.ContractResolver = new TypeHintContractResolver();

        A a = JsonConvert.DeserializeObject<A>(json, jsonSettings);

​

        Assert.IsType<B>(a);

        Assert.IsType<C>(a.Child);

    }

}

​

public class TypeHintValueProvider : IValueProvider

{

    private readonly string _value;

    public TypeHintValueProvider(string value)

    {

        _value = value;

    }

    public void SetValue(object target, object value)

    {

    }

    public object GetValue(object target)

    {

        return _value;

    }

​

}

​

public class TypeHintContractResolver : DefaultContractResolver

{

    public override JsonContract ResolveContract(Type type)

    {

        JsonContract contract = base.ResolveContract(type);

        if ((contract is JsonObjectContract)

            && ((type == typeof(A)) || (type == typeof(B))) ) // In the real implementation, this is checking against a registry of types

        {

            contract.Converter = new TypeHintJsonConverter(type);

        }

        return contract;

    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)

    {

        IList<JsonProperty> result = base.CreateProperties(type, memberSerialization);

        if (type == typeof(A))

        {

            result.Add(CreateTypeHintProperty(type,"Hint", "A"));

        }

        else if (type == typeof(B))

        {

            result.Add(CreateTypeHintProperty(type,"Target", "B"));

        }

        else if (type == typeof(C))

        {

            result.Add(CreateTypeHintProperty(type,"Is", "C"));

        }

        return result;

    }

    private JsonProperty CreateTypeHintProperty(Type declaringType, string propertyName, string propertyValue)

    {

        JsonProperty property = new JsonProperty();

        property.PropertyType = typeof(string);

        property.DeclaringType = declaringType;

        property.PropertyName = propertyName;

        property.ValueProvider = new TypeHintValueProvider(propertyValue);      

        property.Readable = true;

        property.Writable = false;

        return property;    

    }

}

​

​

public class TypeHintJsonConverter : JsonConverter

{

    private readonly Type _declaredType;

​

    public TypeHintJsonConverter(Type declaredType)

    {

        _declaredType = declaredType;

    }

​

    public override bool CanConvert(Type objectType)

    {

        return objectType == _declaredType;

    }

​

    // The real implementation of the next 2 methods uses reflection on concrete types to determine the declaredType hint.

    // TypeFromTypeHint and TypeHintPropertyForType are the inverse of each other.

​

    private Type TypeFromTypeHint(JObject jo)

    {

        if (new JValue("B").Equals(jo["Target"]))

        {

            return typeof(B);

        }

        else if (new JValue("A").Equals(jo["Hint"]))

        {

            return typeof(A);

        }

        else if (new JValue("C").Equals(jo["Is"]))

        {

            return typeof(C);

        }

        else

        {

            throw new ArgumentException("Type not recognized from JSON");

        }

    }

​

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

    {

        if (! CanConvert(objectType))

        {

            throw new InvalidOperationException("Can't convert declaredType " + objectType + "; expected " + _declaredType);

        }

​

        // Load JObject from stream.  Turns out we're also called for null arrays of our objects,

        // so handle a null by returning one.

        var jToken = JToken.Load(reader);

        if (jToken.Type == JTokenType.Null)

            return null;

        if (jToken.Type != JTokenType.Object)

        {

            throw new InvalidOperationException("Json: expected " + _declaredType + "; got " + jToken.Type);

        }

        JObject jObject = (JObject) jToken;

​

        // Select the declaredType based on TypeHint

        Type deserializingType = TypeFromTypeHint(jObject);

​

        var target = Activator.CreateInstance(deserializingType);

        serializer.Populate(jObject.CreateReader(), target);

        return target;

    }

​

    public override bool CanWrite

    {

        get { return false; }

    }

​

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

    {

        throw new NotSupportedException("TypeHintJsonConverter can be only used for deserializing");

    }

​

}