如何使用Json.Net将泛型接口反序列化为具体类型？

Question

如何使用Json.Net将泛型接口反序列化为具体类型？

4

我有以下接口：

public interface IInterface<out M>
{
    M Message { get; }
    string Str { get; }
}

以及它的实现：

public class Implementation<M> : IInterface<M>
{
    public M Message;
    public string Str;

    public Implementation(M message, string str)
    {
        Message = message;
        Str = str;
    }

    M IInterface<M>.Message => this.Message;
    string IInterface<M>.Str => this.Str;
}

这里是一个M系列的样品:

public class Sample
{
    public int X;
}

以下是我从 JavaScript 客户端传递的示例 JSON：

{ "Message" : { "X": 100 }, "Str" : "abc" }

现在有一些遗留/外部代码(我无法更改)，试图使用Json.Net使用DeserializeObject<IInterface<Sample>>(js_object_string)对上述JSON对象进行反序列化。

如何为这个IInterface接口编写一个JsonConverter，以处理其泛型参数M。大多数互联网上的解决方案只适用于编译时已知的类型。

我尝试了下面的代码(我没有完全理解)，但外部代码认为反序列化对象不是IInterface。

static class ReflectionHelper
{
    public static IInterface<T> Get<T>()
    {
        var x = JsonConvert.DeserializeObject<T>(str);
        IInterface<T> y = new Implementation<T>(x, "xyz");
        return y;
    }
}

class MyConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
       return (objectType == typeof(IInterface<>));
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
       var w = Newtonsoft.Json.Linq.JObject.Load(reader);
       var x = typeof(ReflectionHelper).GetMethod(nameof(ReflectionHelper.Get)).MakeGenericMethod(objectType.GetGenericArguments()[0]).Invoke(null, new object[] {  });

       return x;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
       serializer.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; // otherwise I get a circular dependency error.
       serializer.Serialize(writer, value);
    }
}

- AbbasFaisal

1

你是否总是希望将IInterface<M>反序列化为Implementation<M>？ - dbc

是的。因为 IInterface 只有一个名为 Implementation 的实现，我确信它会一直保持这样。至于为什么我需要一个接口的问题，那是一个很长很长的故事，超出了本问题的范围。 - AbbasFaisal

好的。如果您无法修改对“DeserializeObject<IInterface<Sample>>(js_object_string)”的调用并直接传递它，则我更新了我的答案，提供了几种不同的应用“MyConverter”的方法。 - dbc

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- dbc · Accepted Answer

您的MyConverter可以编写如下：

public class MyConverter : JsonConverter
{
    public override bool CanConvert(Type objectType) =>
       objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(IInterface<>);

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (!CanConvert(objectType)) // For safety.
            throw new ArgumentException(string.Format("Invalid type {0}", objectType));
        var concreteType = typeof(Implementation<>).MakeGenericType(objectType.GetGenericArguments());
        return serializer.Deserialize(reader, concreteType);
    }

    public override bool CanWrite => false;

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

然后将其添加到Converters中，用于序列化和反序列化，如下所示：

var settings = new JsonSerializerSettings
{
    Converters = { new MyConverter() },
};
var root = JsonConvert.DeserializeObject<IInterface<Sample>>(js_object_string, settings);

如果您确实不能完全更改调用DeserializeObject<IInterface<Sample>>(js_object_string)，您可以像以下方式一样将转换器添加到Json.NET的当前线程的全局默认设置中：

// Set up Json.NET's global default settings to include MyConverter
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
    {
        Converters = { new MyConverter() },
    };

// And then later, deserialize to IInterface<Sample> via a call that cannot be changed AT ALL:
var root = JsonConvert.DeserializeObject<IInterface<Sample>>(js_object_string);

或者，您可以直接将 MyConverter 应用于 IInterface<out M>，如下所示:

[JsonConverter(typeof(MyConverter))]
public interface IInterface<out M>
{

但是如果你这样做，你必须将此回答中的NoConverter应用于如何使用Json.Net将通用接口反序列化为通用实现类型？中的Implementation<M>，以避免出现堆栈溢出异常：

[JsonConverter(typeof(NoConverter))]
public class Implementation<M> : IInterface<M>
{

注意事项:

通过重写JsonConverter.CanWrite并返回false，我们避免了实现WriteJson()的需要。
在ReadJson()中，我们通过从传入的objectType中提取泛型参数来确定要反序列化的具体类型，该类型必须为IInterface<M>，其中一些M，并且使用相同的泛型参数构造一个具体类型Implementation<M>。
JSON.NET支持从带参数的构造函数进行反序列化，如JSON.net: how to deserialize without using the default constructor?所述。由于您的Implementation<M>具有符合要求的单个带参数的构造函数，因此它被调用以正确反序列化您的具体类。
DefaultSettings适用于应用程序中所有对JsonConvert的调用，来自所有线程，因此您应确定修改这些设置是否适合您的应用程序。
必须将NoConverter应用于Implementation<M>，因为在没有自己的转换器的情况下，它将从IInterface<out M>继承MyConverter，随后在反序列化具体类型时会导致对MyConverter.ReadJson()的递归调用，从而导致堆栈溢出或循环引用异常。(您可以自行调试以确认。)

有关生成“默认”反序列化具体类的其他选项，而不使用转换器，请参见JSON.Net throws StackOverflowException when using [JsonConvert()]或Call default JsonSerializer in a JsonConverter for certain value type arrays。建议构造具体类型的默认实例，然后使用JsonSerializer.Populate()填充它的答案对您不起作用，因为您的具体类型没有默认构造函数。

这里提供了关于DefaultSettings的演示示例，以及MyConverter和NoConverter的演示示例这里。