C# 使用接口和IoC时序列化/反序列化出现问题

我正在尝试反序列化一个json字符串，该字符串包含许多基于接口的集合。我已经实现了一个IContractResolver，并且正在使用一个IoC容器（TinyIoC）将接口解析为具体的类——我遇到的问题是嵌套集合似乎没有使用实际值的具体类填充

这是一个样本

namespace JsonIssue
{
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;

    using Newtonsoft.Json;
    using Newtonsoft.Json.Serialization;

    internal class Program
    {
        private static void Main(string[] args)
        {
            var container = new TinyIoC.TinyIoCContainer();

            container.Register<ISampleInterface1, SampleClass1>();
            container.Register<ISampleInterface2, SampleClass2>();
            container.Register<ISampleInterface3, SampleClass3>();

            var obj1 = new SampleClass1();
            for (int i = 0; i < 10; i++)
            {
                obj1.Items.Add(new SampleClass2 { Name = string.Format("Item {0}", i), Items = new List<ISampleInterface3> { new SampleClass3 { Name = "shawn 1"}} });
            }

            var js = new JsonSerializerSettings
                         {
                             TypeNameHandling = TypeNameHandling.None,
                             ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
                             NullValueHandling = NullValueHandling.Ignore,
                             ContractResolver = new SampleContractResolver(container)
                         };

            var s = JsonConvert.SerializeObject(obj1);

            var r = JsonConvert.DeserializeObject<SampleClass1>(s, js);

            Debug.WriteLine(r);
        }
    }

    public interface ISampleInterface1
    {
        string Name { get; set; }

        ICollection<ISampleInterface2> Items { get; set; }
    }

    public interface ISampleInterface2
    {
        string Name { get; set; }

        ICollection<ISampleInterface3> Items { get; set; }
    }

    public interface ISampleInterface3
    {
        string Name { get; set; }
    }

    public class SampleClass1 : ISampleInterface1
    {
        public SampleClass1()
        {
            Items = new List<ISampleInterface2>();
        }

        public string Name { get; set; }

        public ICollection<ISampleInterface2> Items { get; set; }
    }

    public class SampleClass2 : ISampleInterface2
    {
        public SampleClass2()
        {
            Items = new List<ISampleInterface3>();
        }

        public string Name { get; set; }

        public ICollection<ISampleInterface3> Items { get; set; }
    }

    public class SampleClass3 : ISampleInterface3
    {
        public string Name { get; set; }
    }

    public class SampleContractResolver : DefaultContractResolver
    {
        private readonly TinyIoC.TinyIoCContainer _container;

        public SampleContractResolver(TinyIoC.TinyIoCContainer container)
        {
            _container = container;
        }

        public override JsonContract ResolveContract(Type type)
        {
            var contract = base.CreateObjectContract(type);

            if (this._container.CanResolve(type))
            {
                contract.DefaultCreator = () => this._container.Resolve(type);
            }

            return contract;
        }
    }
}

名称空间JsonIssue
{
使用制度；
使用System.Collections.Generic；
使用系统诊断；
使用Newtonsoft.Json；
使用Newtonsoft.Json.Serialization；
内部课程计划
{
私有静态void Main（字符串[]args）
{
var container=new TinyIoC.TinyIoCContainer（）；
container.Register（）；
container.Register（）；
container.Register（）；
var obj1=新样本类别1（）；
对于（int i=0；i<10；i++）
{
obj1.Items.Add（new-SampleClass2{Name=string.Format（“Item{0}”，i），Items=new-List{new-SampleClass3{Name=“shawn 1”}}）；
}
var js=新的JsonSerializerSettings
{
TypeNameHandling=TypeNameHandling.None，
ReferenceLoopHandling=ReferenceLoopHandling.Ignore，
NullValueHandling=NullValueHandling.Ignore，
ContractResolver=新样本ContractResolver（容器）
};
var s=JsonConvert.SerializeObject（obj1）；
var r=JsonConvert.DeserializeObject（s，js）；
Debug.WriteLine（r）；
}
}
公共接口是SampleInterface1
{
字符串名称{get；set；}
ICollection项{get；set；}
}
公共接口是SampleInterface2
{
字符串名称{get；set；}
ICollection项{get；set；}
}
公共接口是SampleInterface3
{
字符串名称{get；set；}
}
公共类样本Class1:ISampleInterface1
{
公共样本类别1（）
{
项目=新列表（）；
}
公共字符串名称{get；set；}
公共ICollection项{get；set；}
}
公共类示例Class2:ISampleInterface2
{
公共样本类别2（）
{
项目=新列表（）；
}
公共字符串名称{get；set；}
公共ICollection项{get；set；}
}
公共类示例Class3:ISampleInterface3
{
公共字符串名称{get；set；}
}
公共类SampleContractResolver:DefaultContractResolver
{
私有只读TinyIoC.TinyIoCContainer\u container；
公共SampleContractResolver（TinyIoC.TinyIoCContainer）
{
_容器=容器；
}
公共重写JsonContract ResolveContract（类型）
{
var contract=base.CreateObjectContract（类型）；
if（此._容器.CanResolve（类型））
{
contract.DefaultCreator=（）=>此._container.Resolve（类型）；
}
退货合同；
}
}
}

有人有什么想法吗？