JsonConverter属性:使用自定义构造函数和autofacc进行反序列化

您可以按照以下步骤实现您的目标:

1. 为你的ICustomObjectCreator接口创建一个非通用接口，使创建对象更方便。
2. 引入一个通用的ObjectCreatorBase<T>基类来调用通用的Create方法。
3. 创建并设置JsonConvert使用的默认设置。
4. 设置AutofacContractResolver为ContractResolver

请看下面的例子来帮助你开始:

void Main()
{
    var builder = new ContainerBuilder();
    builder.RegisterType<QueryObjectCreator>()
        .As<ICustomObjectCreator<IQuery>>()
        .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);
}
// Define other methods and classes here
public class AutofacContractResolver : DefaultContractResolver
{
    private readonly IContainer _container;
    public AutofacContractResolver(IContainer container)
    {
        _container = container;
    }
    protected override JsonObjectContract CreateObjectContract(Type objectType)
    {
        JsonObjectContract contract = base.CreateObjectContract(objectType);
        var customObjectCreatorType = typeof(ICustomObjectCreator<>).MakeGenericType(objectType);
        if (!_container.IsRegistered(customObjectCreatorType))
            return contract;
        var customObjectCreator = (ICustomObjectCreator) _container.Resolve(customObjectCreatorType);
        // I don't know how you want to obtain the string which shall be passed to CreateObject
        contract.DefaultCreator = () => customObjectCreator.CreateObject("XYZ");
        return contract;
    }
}
public interface ICustomObjectCreator
{
    object CreateObject(string type);
}
public interface ICustomObjectCreator<out T> : ICustomObjectCreator
{
    T Create(string type);
}
public abstract class ObjectCreatorBase<T> : ICustomObjectCreator<T>
{
    public object CreateObject(string type)
    {
        return Create(type);
    }
    public abstract T Create(string type);
}
public class QueryObjectCreator : ObjectCreatorBase<IQuery>
{
    public override 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; }
}

输出应该是

Create called
42

也许你可以通过简单地使用Autofac直接创建对象来删除所有ICustomObjectCreator实例来简化代码。

第一种方法是有效的，但是它没有考虑到你需要得到一个字符串来决定你要创建哪种类型的对象(type)。

要使其工作，可以执行以下命令:

1. 注册CustomConverter为generic
2. 覆盖ResolveContractConverter方法，以在任何ICustomObjectCreator已注册为该类型时返回转换器的实例。
3. 修改DefaultSettings，使AutofacContractResolver被使用。

请看下面的例子:

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);
}
// Define other methods and classes here
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; }
    // 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)?.Value<string>();
        return ObjectCreator.Create(type);
    }
}
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; }
}

输出应该是

Constructor called
Create called
42

假设有如下自动设置:

public class AutofacContractResolver : DefaultContractResolver
{
    private readonly IContainer _container;
    public AutofacContractResolver(IContainer container)
    {
        _container = container;
    }
    protected override JsonObjectContract CreateObjectContract(Type objectType)
    {
        JsonObjectContract contract = base.CreateObjectContract(objectType);
        // use Autofac to create types that have been registered with it
        if (_container.IsRegistered(objectType))
        {
           contract.DefaultCreator = () => _container.Resolve(objectType);
        }  
        return contract;
    }
}

然后，假设你的类是这样的:

public class TaskController
{
    private readonly ITaskRepository _repository;
    private readonly ILogger _logger;
    public TaskController(ITaskRepository repository, ILogger logger)
    {
        _repository = repository;
        _logger = logger;
    }
    public ITaskRepository Repository
    {
        get { return _repository; }
    }
    public ILogger Logger
    {
        get { return _logger; }
    }
}

因此，解析器在反序列化中的用法如下:

ContainerBuilder builder = new ContainerBuilder();
builder.RegisterType<TaskRepository>().As<ITaskRepository>();
builder.RegisterType<TaskController>();
builder.Register(c => new LogService(new DateTime(2000, 12, 12))).As<ILogger>();
IContainer container = builder.Build();
AutofacContractResolver contractResolver = new AutofacContractResolver(container);
string json = @"{
      'Logger': {
        'Level':'Debug'
      }
}";
// ITaskRespository and ILogger constructor parameters are injected by Autofac 
TaskController controller = JsonConvert.DeserializeObject<TaskController>(json, new JsonSerializerSettings
{
    ContractResolver = contractResolver
});
Console.WriteLine(controller.Repository.GetType().Name);

您可以在http://www.newtonsoft.com/json/help/html/DeserializeWithDependencyInjection.htm