C# Newtonsoft：如何在没有 Json 属性的情况下反序列化包含接口的接口

假设应始终反序列化为 、as 和 as ，您可以使用三个实例 of 来反序列化 JSON，每个接口一个，其中转换器从这个答案中获取 Json.Net - 对基于接口的数据结构进行性能反序列化？IAAIBBICCInterfaceToConcreteConverter<TInterface, TConcrete>

public class InterfaceToConcreteConverter<TInterface, TConcrete> : JsonConverter where TConcrete : TInterface
{
    static InterfaceToConcreteConverter()
    {
        // TConcrete should be a subtype of an abstract type, or an implementation of an interface.  If they
        // are identical an infinite recursion could result, so throw an exception.
        if (typeof(TInterface) == typeof(TConcrete))
            throw new InvalidOperationException(string.Format("typeof({0}) == typeof({1})", typeof(TInterface), typeof(TConcrete)));
    }

    public override bool CanConvert(Type objectType) =>objectType == typeof(TInterface);
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) => serializer.Deserialize(reader, typeof(TConcrete));
    public override bool CanWrite => false;
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) => throw new NotImplementedException();
}

使用此转换器，序列化代码将如下所示：

var settings = new JsonSerializerSettings
{
    Converters = { new InterfaceToConcreteConverter<IA, A>(), 
                  new InterfaceToConcreteConverter<IB, B>(),
                  new InterfaceToConcreteConverter<IC, C>(),}
};

string aSer = JsonConvert.SerializeObject( a, settings );

A aDeser = JsonConvert.DeserializeObject<A>( aSer, settings );

笔记：

• 这个答案取决于每个接口都有一个且只有一个具体实现的事实。如果这不正确，则需要使用某种以前序列化的类型标识符来确定具体类型。

• 单一责任原则是你的朋友。创建一个通用接口到具体转换器并实例化三个实例比为所有接口创建一些综合转换器要容易得多。

  如果有许多不同的位置需要使用转换器进行序列化或反序列化，则可以创建静态默认设置以供项目范围使用：

  public static class JsonExtensions
  {
      public static JsonSerializerSettings DefaultSettings { get; } =
          new JsonSerializerSettings
          {
              Converters = { new InterfaceToConcreteConverter<IA, A>(), 
                            new InterfaceToConcreteConverter<IB, B>(),
                            new InterfaceToConcreteConverter<IC, C>(),}
          };
  }
  
  A aDeser = JsonConvert.DeserializeObject<A>( aSer, JsonExtensions.DefaultSettings );
  

• 通过从 CanWrite 返回，写入时将使用默认序列化。false

演示小提琴在这里。

您需要将序列化程序传递给所有调用，以便它可以递归调用转换器（而不是使用 default）：ToObject

B retVal = jsonObject.ToObject<B>(serializer);

您可以在类属性（而不是接口）上使用这些特性。由于此转换器不使用任何接口，因此它不需要每个接口都有一个且只有一个具体实现（因为@dbc解决方案需要）

A aDeser = JsonConvert.DeserializeObject<A>(aSer);

public class CustomInterfaceConverter : JsonConverter
{
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JToken o = JToken.Load(reader);
        return o.ToObject(Type.GetType((string)o["TypeName"]));
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override bool CanConvert(Type objectType) => objectType == typeof(AType);
    public override bool CanWrite => false;
}

类

public abstract class AType
{
    public string TypeName
    {
        get { return this.GetType().Name; }
    }
}

public class A : AType, IA
{
    public A() { }
    [JsonConverter(typeof(CustomInterfaceConverter))]
    public IB b { get; set; }
}
public class B : AType, IB
{
    public B() { }

    public B(IC pC)
    {
        c = pC;
    }
    [JsonConverter(typeof(CustomInterfaceConverter))]
    public IC c { get; set; }
}
public class C : AType, IC
{
    public C() { }

    public C(int pV)
    {
        v = pV;
    }

    public int v { get; set; }
}