Interface net反序列化接口，具体类使用JsonConverter

我的问题是，当转换器应用于接口的实现时，json.net反序列化过程似乎不会调用我的JsonConverter，而propertytype就是接口。 我使用typenameholling=typenameholling.Objects将$type添加到json中。我对序列化和反序列化都这样做。 当我有一个接口实现的属性时，类的转换器被正确调用。 但是当我有一个接口类型的属性时，不会调用具体类的converter

当我反序列化这个类时，我的JsonDataBagCreationConverter将被RealTelephone调用，但不会被电话调用，因为这是一个接口。 即使它们都是用正确的$type序列化的。 这导致RealTelephone的.Data已填充，而Phoners.Data为空

[JsonConverter(typeof(JsonDataBagCreationConverter<ContainerForITelephone>))]
public class ContainerForITelephone : IDataBag
{
    private object _data;
    private DataBagTypeEnum _dataBagTypeEnum;
    public ITelephone Telephone { get; set; }
    public Telephone RealTelephone { get; set; }

    public object Data
    {
        get { return _data; }
        set { _data = value; }
    }

    public DataBagTypeEnum DataBagType_Enum
    {
        get { return _dataBagTypeEnum; }
    }
}

[JsonConverter（类型（JsonDataBagCreationConverter））]
公共类集装箱电话：IDataBag
{
私有对象数据；
专用DataBagTypeEnum_DataBagTypeEnum；
公用电话{get；set；}
公用电话不动产电话{get；set；}
公共对象数据
{
获取{return_data；}
设置{u data=value；}
}
公共数据包类型枚举数据包类型枚举
{
获取{return}dataBagTypeEnum；}
}
}

不会为电话属性调用此jsonconverter。但这是给RealTelephone的

public class JsonDataBagCreationConverter<T> : JsonConverter where T : IDataBag, new()
{       
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {           
        if (reader.TokenType != JsonToken.Null) 
        {
            var jsonObject = JObject.Load(reader);
            var target = Create(objectType, jsonObject);
            serializer.Populate(jsonObject.CreateReader(), target); 
            ((IDataBag)target).Data = jsonObject.ToString(); 
            return target;
        }
        return null;
    }

公共类JsonDataBagCreationConverter:JsonConverter其中T:IDataBag，new（）
{       
公共重写对象ReadJson（JsonReader阅读器，类型objectType，对象existingValue，JsonSerializer序列化程序）
{           
if（reader.TokenType！=JsonToken.Null）
{
var jsonObject=JObject.Load（读卡器）；
var target=Create（objectType，jsonObject）；
填充（jsonObject.CreateReader（），目标）；
（（IDataBag）target.Data=jsonObject.ToString（）；
回报目标；
}
返回null；
}

}

[JsonConverter（类型（JsonDataBagCreationConverter））]
公共电话：ITelephone
{
公共字符串名称{get；set；}
公共字符串区域代码{get；set；}
公共字符串编号{get；set；}
公共子电话子电话{get；set；}
公共对象数据{get；set；}
公共数据包类型枚举数据包类型_枚举{get；set；}
}

我期待着您的来信，谢谢

一月

解决：

public class JsonDataBagCreationConverter<T> : JsonConverter where T:IDataBag 
{

//, new() prevented us from using interfaces. Activator.CreateInstance did the trick in Create

//Used when the object decorated with  [JsonConverter(typeof(JsonDataBagCreationConverter<xxxx>))] is de-serialized
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var  jsonObject = JObject.Load(reader);

        if (objectType.IsInterface)
        {
            // Interfaces cannot be instantiated but must be converted to their "real" implemented type
            // Because we serialize with settings.TypeNameHandling = TypeNameHandling.Objects; 
            // A $type property is added to the json by the deserializer.
            string type = jsonObject["$type"].ToString();
            var typesAsArray = type.Split(',');
            var wrappedTarget = Activator.CreateInstance(typesAsArray[1], typesAsArray[0]);
            var realTarget = wrappedTarget.Unwrap() as IDataBag; 
            serializer.Populate(jsonObject.CreateReader(), realTarget); // Will call this function recursively for any objects that have JsonDataBagCreationConverter as attribute
            ((IDataBag)realTarget).Data = jsonObject.ToString(); // This is where custom data is stored in databag
            return realTarget; 
        }

        // Non interface
        var target = Create(objectType, jsonObject);
        serializer.Populate(jsonObject.CreateReader(), target); // Will call this function recursively for any objects that have JsonDataBagCreationConverter as attribute
        ((IDataBag)target).Data = jsonObject.ToString(); // This is where custom data is stored in databag
        return target;


}

public override bool CanRead
{
    get
    {
        return true; 
    }
}

public override bool CanWrite
{
    get
    {
        return false; 
    }
}

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
    throw new Exception("WriteJson not implemented");
}

protected IDataBag Create(Type objectType, JObject jsonObject)
{
    var aa = Activator.CreateInstance(objectType);
    return aa as IDataBag;
    // return new T(); // this demands ,new() on the class and then it will not work with interfaces
}

public override bool CanConvert(Type objectType)
{
    return typeof(T).IsAssignableFrom(objectType);
}

公共类JsonDataBagCreationConverter:JsonConverter其中T:IDataBag
{
//，new（）阻止我们使用接口。Activator.CreateInstance在Create中使用了这个技巧
//反序列化用[JsonConverter（typeof（JsonDataBagCreationConverter））]修饰的对象时使用
公共重写对象ReadJson（JsonReader阅读器，类型objectType，对象existingValue，JsonSerializer序列化程序）
{
var jsonObject=JObject.Load（读卡器）；
if（objectType.IsInterface）
{
//接口无法实例化，但必须转换为其“真实”实现类型
//因为我们使用settings.typenameholling=typenameholling.Objects序列化；
//反序列化程序将$type属性添加到json中。
string type=jsonObject[“$type”].ToString（）；
var typesAsArray=type.Split（'，'）；
var wrappedTarget=Activator.CreateInstance（typesAsArray[1]，typesAsArray[0]）；
var realTarget=wrappedTarget.Unwrap（）作为IDataBag；
serializer.Populate（jsonObject.CreateReader（），realTarget）；//将递归调用此函数，用于将JsonDataBagCreationConverter作为属性的任何对象
（（IDataBag）realtTarget.Data=jsonObject.ToString（）；//这是自定义数据存储在数据库中的位置
返回真实目标；
}
//非接口
var target=Create（objectType，jsonObject）；
serializer.Populate（jsonObject.CreateReader（），target）；//将递归调用此函数，用于将JsonDataBagCreationConverter作为属性的任何对象
（（IDataBag）target.Data=jsonObject.ToString（）；//这是自定义数据存储在数据包中的位置
回报目标；
}
公共覆盖布尔可读取
{
得到
{
返回true；
}
}
公共覆盖布尔可写
{
得到
{
返回false；
}
}
公共重写void WriteJson（JsonWriter编写器、对象值、JsonSerializer序列化器）
{
抛出新异常（“WriteJson未实现”）；
}
受保护的IDataBag创建（类型objectType，JObject jsonObject）
{
var aa=Activator.CreateInstance（objectType）；
将aa作为IDataBag返回；
//return new T（）；//这要求在类上使用new（），然后它将不能与接口一起工作
}
公共覆盖布尔CanConvert（类型objectType）
{
返回typeof（T）.IsAssignableFrom（objectType）；
}

}

已解决：

public class JsonDataBagCreationConverter<T> : JsonConverter where T:IDataBag 
{

//, new() prevented us from using interfaces. Activator.CreateInstance did the trick in Create

//Used when the object decorated with  [JsonConverter(typeof(JsonDataBagCreationConverter<xxxx>))] is de-serialized
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var  jsonObject = JObject.Load(reader);

        if (objectType.IsInterface)
        {
            // Interfaces cannot be instantiated but must be converted to their "real" implemented type
            // Because we serialize with settings.TypeNameHandling = TypeNameHandling.Objects; 
            // A $type property is added to the json by the deserializer.
            string type = jsonObject["$type"].ToString();
            var typesAsArray = type.Split(',');
            var wrappedTarget = Activator.CreateInstance(typesAsArray[1], typesAsArray[0]);
            var realTarget = wrappedTarget.Unwrap() as IDataBag; 
            serializer.Populate(jsonObject.CreateReader(), realTarget); // Will call this function recursively for any objects that have JsonDataBagCreationConverter as attribute
            ((IDataBag)realTarget).Data = jsonObject.ToString(); // This is where custom data is stored in databag
            return realTarget; 
        }

        // Non interface
        var target = Create(objectType, jsonObject);
        serializer.Populate(jsonObject.CreateReader(), target); // Will call this function recursively for any objects that have JsonDataBagCreationConverter as attribute
        ((IDataBag)target).Data = jsonObject.ToString(); // This is where custom data is stored in databag
        return target;


}

public override bool CanRead
{
    get
    {
        return true; 
    }
}

public override bool CanWrite
{
    get
    {
        return false; 
    }
}

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
    throw new Exception("WriteJson not implemented");
}

protected IDataBag Create(Type objectType, JObject jsonObject)
{
    var aa = Activator.CreateInstance(objectType);
    return aa as IDataBag;
    // return new T(); // this demands ,new() on the class and then it will not work with interfaces
}

public override bool CanConvert(Type objectType)
{
    return typeof(T).IsAssignableFrom(objectType);
}

公共类JsonDataBagCreationConverter:JsonConverter其中T:IDataBag
{
//，new（）阻止我们使用接口。Activator.CreateInstance在Create中使用了这个技巧
//反序列化用[JsonConverter（typeof（JsonDataBagCreationConverter））]修饰的对象时使用
公共重写对象ReadJson（JsonReader阅读器，类型objectType，对象existingValue，JsonSerializer序列化程序）
{
var jsonObject=JObject.Load（读卡器）；
if（objectType.IsInterface）
{
//接口无法实例化，但必须转换为其“真实”实现类型
//因为我们使用settings.typenameholling=typenameholling.Objects序列化；
//反序列化程序将$type属性添加到json中。
string type=jsonObject[“$type”].ToString（）；
var typesAsArray=type.Split（'，'）；
var wrappedTarget=Activator.CreateInstance（typesAsArray[1]，typesAsArray[0]）；
var realTarget=wrappedT