using System;

using Autofac;

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Serialization;

​

public class Program

{

    public static void Main()

    {

        var builder = new ContainerBuilder();

        builder.RegisterType<QueryObjectCreator>()

            .As<ICustomObjectCreator<IQuery>>()

            .InstancePerLifetimeScope();

        builder.RegisterGeneric(typeof(CustomConverter<>)).AsSelf().InstancePerLifetimeScope();

        var container = builder.Build();

        Func<JsonSerializerSettings> settingsFactory = () =>

        {

            var settings = new JsonSerializerSettings();

            settings.ContractResolver = new AutofacContractResolver(container);

            return settings;

        };

        JsonConvert.DefaultSettings = settingsFactory;

        var myObject = new MyObject { Query = new Query(42) };

        var json = JsonConvert.SerializeObject(myObject);

        myObject = JsonConvert.DeserializeObject<MyObject>(json);

        Console.WriteLine(myObject.Query.MyProperty);

    }

}

​

public class AutofacContractResolver : DefaultContractResolver

{

    private readonly IContainer _container;

​

    public AutofacContractResolver(IContainer container)

    {

        _container = container;

    }

​

    protected override JsonConverter ResolveContractConverter(Type objectType)

    {

        var customObjectCreatorType = typeof(ICustomObjectCreator<>).MakeGenericType(objectType);

        if (!_container.IsRegistered(customObjectCreatorType))

            return base.ResolveContractConverter(objectType);

        var customConverterType = typeof(CustomConverter<>).MakeGenericType(objectType);

        return (JsonConverter) _container.Resolve(customConverterType);

    }

}

​

public class CustomConverter<T> : JsonConverter

{

    // This should be created via AutoFac

    public ICustomObjectCreator<T> ObjectCreator { get; set; }

​

    // This default constructr always gets called

    public CustomConverter() { }

​

    // I want to call this constructor

    public CustomConverter(ICustomObjectCreator<T> objectCreator)

    {

        Console.WriteLine("Constructor called");

        ObjectCreator = objectCreator;

    }

​

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

    {

        if (reader.TokenType == JsonToken.Null)

            return null;

​

        // Load JObject from stream 

        var jObject = JObject.Load(reader);

​

        // Create target object based on JObject 

        var target = Create(objectType, jObject);

​

        // Populate the object properties 

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

​

        return target;

    }

​

    protected T Create(Type objectType, JObject jObject)

    {

        var type = jObject.GetValue("type", StringComparison.OrdinalIgnoreCase);

        return ObjectCreator.Create(type != null ? type.Value<string>() : null);

    }

​

    public override bool CanConvert(Type type)

    {

        return type == typeof(T);

    }

​

    public override void WriteJson(JsonWriter jsonWriter, object o, JsonSerializer serializer)

    {

​

    }

}

​

public interface ICustomObjectCreator<out T> 

{

    T Create(string type);

}

​

public class QueryObjectCreator : ICustomObjectCreator<IQuery>

{

    public IQuery Create(string type)

    {

        Console.WriteLine("Create called");

        // ... some logic to create a concrete object

        var concreteObject = new Query();

        return (IQuery)concreteObject;

    }

}

​

public interface IQuery

{

    int MyProperty { get; set; }

}

​

public class Query : IQuery

{

    public int MyProperty { get; set; }

    public Query()

    {

    }

    public Query(int myProperty)

    {

        MyProperty = myProperty;

    }

}

​

public class MyObject

{

    public IQuery Query { get; set; }

}

​

​