C#Json。使用对象反序列化，子类使用接口

我有一些物品：

public class MyObject
{
    public MyField Field { get; set; }
}

public class MyField
{
    [JsonProperty]
    public Entity MyEntity { get; set; }
    public IEntity IMyEntity { get; set; }
}

public interface IEntity
{
    string MyStr { get; }
}

public class Entity : IEntity
{
}

然后我试着做一些类似的事情

JsonConvert.DeserializeObject<MyObject>(myObjStr); 

JsonConvert.DeserializeObject（myObjStr）；

它抛出一个类似于

无法创建MyObject类型的实例。。。类型是接口或抽象类，无法实例化。路径'MyField.IMyEntity.MyInt'

---

我无法更改字段或实体，因为它位于另一个组的代码库中。MyObject类在我的类中。有没有反序列化此对象的方法？我在这里尝试了一些JsonSerializerSettings的方法，但没有效果

您可以创建自己的JSON转换器，它允许您指定类型映射：

public class JsonTypeMapper<TFromType, TToType> : JsonConverter
{
    public override bool CanConvert(Type objectType) => objectType == typeof(TFromType);

    public override object ReadJson(JsonReader reader,
     Type objectType, object existingValue, JsonSerializer serializer)
    {
        return serializer.Deserialize<TToType>(reader);
    }

    public override void WriteJson(JsonWriter writer,
        object value, JsonSerializer serializer)
    {
        serializer.Serialize(writer, value);
    }
}

公共类JsonTypeMapper:JsonConverter
{
公共覆盖布尔CanConvert（类型objectType）=>objectType==typeof（TFromType）；
公共重写对象ReadJson（JsonReader，
类型objectType、对象existingValue、JsonSerializer序列化程序）
{
返回序列化程序。反序列化（读取器）；
}
public override void WriteJson（JsonWriter writer，
对象值，JsonSerializer序列化程序）
{
serializer.Serialize（writer，value）；
}
}

然后按如下方式反序列化：

JsonConvert.DeserializeObject<MyObject>(myObjStr, new JsonSerializerSettings
{
    Converters = new List<JsonConverter> { new JsonTypeMapper<IEntity, Entity>() }
                                                            //^^^^^^^, ^^^^^^
}); 

JsonConvert.DeserializeObject（myObjStr，新的JsonSerializerSettings
{
转换器=新列表{new JsonTypeMapper（）}
//^^^^^^^, ^^^^^^
}); 

为了使编写更简单，您可以重写并返回

false

@dbc Correct！虽然

WriteJson

实际上是一个抽象方法，但是我们必须用抛出

NotImplementedException

（或类似）来替换实现。如果

JsonTypeMapper

本身打算被重写（或抽象），我肯定会坚持使用

CanWrite

，但作为首选，我会尽量避免

NotImplementedException

。