c# - 如何将 JSON 包装的集合属性反序列化为泛型类？

Question

问题

许多 RESTful JSON API 返回包装在对象中的集合。
在这种情况下，还有另一个属性包含集合中的项目数。

两个例子:

{
    "animals": [
        {"name": "Raven", "wings": 2},
        {"name": "Wolf", "wings": 0}
    ],
    "count": 2
}

{
    "vehicles": [
        {"type": "Car", "wheels": 4},
        {"type": "Motorcycle", "wheels": 2}
        {"type": "Boat", "wheels": 0}
    ],
    "count": 3
}

请注意，这些根对象并不相同，因为它们包含集合的名称。

这在 JavaScript 等弱类型语言中不是问题，但在强类型语言中，如果有很多类似的包装对象，这就会成为问题。

没有泛型

当然这些可以像这样反序列化:

class AnimalsResponse 
{
    public List<Animal> Animals { get; set; }
    public int Count { get; set; }
}

class Animal
{
    public string Name { get; set; }
    public int Wings { get; set; }
}

JsonConvert.DeserializeObject<AnimalsResponse>(content);

class VehiclesResponse 
{
    public List<Vehicle> Vehicles { get; set; }
    public int Count { get; set; }
} 

class Vehicle
{
    public string Type { get; set; }
    public int Wheels { get; set; }
}

JsonConvert.DeserializeObject<VehiclesResponse>(content);

使用泛型

由于根对象总是采用相同的格式，除了集合的名称，反序列化为泛型类型是可取的:

class CollectionResponse<T>
{
    public List<T> Items { get; set; }
    public int Count { get; set; }
}

(可能过于复杂)解决方案

我已经尝试(成功地)使用自定义反序列化器执行此操作，但对于这样一个常见问题，此解决方案似乎过于复杂。

class CollectionJsonConverter : JsonConverter
{
    private readonly string collectionName;

    public CollectionJsonConverter(string collectionName) : base()
    {
        this.collectionName = collectionName ?? throw new ArgumentNullException(nameof(collectionName));
    }

    public override bool CanConvert(Type objectType)
    {
        return objectType.IsGenericType && 
            objectType.GetGenericTypeDefinition() == typeof(CollectionResponse<>);
    }

    public override object ReadJson(JsonReader reader, 
        Type objectType, object existingValue, JsonSerializer serializer)
    {
        var instance = Activator.CreateInstance(objectType);

        var objectProperties = objectType.GetTypeInfo().DeclaredProperties.ToList();
        var objectProperty = objectProperties.FirstOrDefault(pi =>
            pi.Name == nameof(CollectionResponse<object>.Items));

        var jsonProperties = JObject.Load(reader).Properties();
        var jsonProperty = jsonProperties.FirstOrDefault(p => p.Name == collectionName);

        objectProperty?.SetValue(instance, 
            jsonProperty.Value.ToObject(objectProperty.PropertyType, new JsonSerializer()));

        return instance;
    }

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

JsonConvert.DeserializeObject<CollectionResponse<T>>(content, new CollectionJsonConverter(collectionName));

其中 collectionName 是集合的名称(如上述示例中的 “animals” 或 “vehicles”)。
不幸的是，这增加了一个额外的参数来处理。

问题

有没有更简单的方法来实现这一点，最好没有自定义反序列化器？

Answer 1

没有自定义 JsonConverter 就无法完成您的要求或自定义 ContractResolver .我认为 JsonConverter在这里实际上是一个很好的方法，但是您可以将其简化很多，这样您就不需要传入集合名称，也不需要反射来设置 Items。属性:

class CollectionJsonConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType.IsGenericType &&
            objectType.GetGenericTypeDefinition() == typeof(CollectionResponse<>);
    }

    public override object ReadJson(JsonReader reader,
        Type objectType, object existingValue, JsonSerializer serializer)
    {
        // load the JSON into a JObject
        var obj = JObject.Load(reader);

        // we expect one and only one list of items; don't care what its name is
        var itemsProp = obj.Properties().Single(p => p.Value.Type == JTokenType.Array);

        // replace the existing list property with a new one called "Items"
        itemsProp.Replace(new JProperty("Items", itemsProp.Value));

        // create an instance of the CollectionResponse model
        var instance = Activator.CreateInstance(objectType);

        // populate it from the modified JObject
        serializer.Populate(obj.CreateReader(), instance);

        return instance;
    }

    public override bool CanWrite => false;

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

此外，您还可以装饰您的 CollectionResponse<T>类 [JsonConverter]属性将转换器绑定(bind)到类，这样您就不必担心在反序列化时传递转换器:

[JsonConverter(typeof(CollectionJsonConverter))]
class CollectionResponse<T>
{
    public List<T> Items { get; set; }
    public int Count { get; set; }
}

然后你可以像这样反序列化(例如):

var vehiclesResp = JsonConvert.DeserializeObject<CollectionResponse<Vehicle>>(vehiclesJson);

工作演示:https://dotnetfiddle.net/D3q8ub