Question

My problem is that I need to deserialize JSON to a type that in turn contains interface type objects, and thus am required to instruct Json.NET on how to convert that interface type, but am not in control of the Newtonsoft.Json.Deserializer directly. The deserialization is handled indirectly by framework code, i.e. by HttpContent.ReadAsAsync<T>.

How can I specify a conversion from the interface type to a concrete type, without being able to add a converter to JsonSerializer.Converters directly? If I use the [JsonConverter] attribute on the interface definition, the converter also gets called for implementations of the interface (i.e., the concrete type I’m converting to).

The below code shows a C# console program that attempts to deserialize the same JSON to first the Parent2 class and then the Parent1 class, instructing Json.NET to convert the IChild1 interface type to the Child1 concrete type via JsonConverterAttribute. The deserialization to Parent2 works since I add ChildConverter directly to serializer.Converters, whereas deserializing to Parent1 results in a stack overflow exception, due to ChildConverter.Deserialize being called even for the Child1 type.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using System.IO;

namespace TestConsole
{
    [JsonConverter(typeof(ChildConverter))]
    interface IChild1
    {
        string Name { get; set; }
    }

    class Child1 : IChild1
    {
        public string Name { get; set; }
    }

    class Parent1
    {
        public IEnumerable<IChild1> Children { get; set; }
    }

    interface IChild2
    {
        string Name { get; set; }
    }

    class Child2 : IChild2
    {
        public string Name { get; set; }
    }

    class Parent2
    {
        public IEnumerable<IChild2> Children { get; set; }
    }

    class ChildConverter : JsonConverter
    {
        public override bool CanConvert(Type objectType)
        {
            return objectType == typeof(IChild1) || objectType == typeof(IChild2);
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (objectType == typeof(IChild1))
                return serializer.Deserialize<Child1>(reader);
            return serializer.Deserialize<Child2>(reader);
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            throw new NotImplementedException();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var json = "{'Children': [{'Name': 'Child1'}, {'Name': 'Child2'}]}";

            var serializer = new JsonSerializer();

            serializer.Converters.Add(new ChildConverter());
            var obj = serializer.Deserialize(new StringReader(json), typeof(Parent2));

            serializer = new JsonSerializer();
            obj = serializer.Deserialize(new StringReader(json), typeof(Parent1));
        }
    }
}

Answer 1

I found a solution to my particular problem, being to call HttpContent.ReadAsAsync<T> and have that deserialize a JSON response. While my solution doesn’t resolve the general problem of configuring Json.NET type conversion without access to the serializer, it does resolve my particular problem. What I found is that HttpContent.ReadAsync<T> accepts an IEnumerable<MediaTypeFormatter>, that is used to deserialize the response. Here one can pass a JsonMediaTypeFormatter, which has been configured with your JsonConverter of choice (in my example, ChildConverter).

var formatter = new JsonMediaTypeFormatter();
formatter.SerializerSettings.Converters.Add(new ChildConverter());
var obj = await resp.Content.ReadAsAsync<T>(new MediaTypeFormatter[] {formatter});