Question

我有一个可以调用两个不同版本服务的客户端。

一项服务只发送一个值：

{
  "value" : { ... }
}

第二个服务总是返回多个值：

{
  "values" : [ 
    { ... },
    { ... }
  ]
}

理想情况下，我想在客户端类中使用单个对象来表示这一点，因此用户永远不会看到它是单个值还是多个值。

public class MyValues
{
  public List<Stuff> Values { get; set; }
  public Thing Other { get; set; }
}

我认为我能够实现这一目标的唯一方法是使用自定义JsonConverter类，我将其应用于MyValues，但我真的只想做一些自定义的事情。反序列化属性value。我似乎无法弄清楚IContractResolver是否是更好的方法（例如以某种方式将幻像属性附加到反序列化value并将其放入Values的MyValues中

如果我创建一个自定义转换器，如何告诉它通常反序列化其他所有内容（例如，如果Other具有额外的属性，请确保它们得到适当处理等）。

Answer 1

您可以在JsonConverter上创建仅限Value的设置，而不是撰写MyValues，如下所示：

public class MyValues
{
    [JsonProperty]
    Stuff Value
    {
        set
        {
            (Values = Values ?? new List<Stuff>(1)).Clear();
            Values.Add(value);
        }
    }

    public List<Stuff> Values { get; set; }
    public Thing Other { get; set; }
}

如果标有[JsonProperty]，则可以是公开的或私人的。在这种情况下，如果在JSON中遇到单例Value属性，Json.NET将调用"value" setter，如果遇到数组Values属性，则调用"values" setter 。由于该属性是set-only，因此只会重新序列化数组属性。

Answer 2

要使custom JsonConverter对某个类型的属性进行特殊处理，但对剩余部分使用默认处理，可以将JSON加载到JObject，分离并处理自定义属性，然后使用JsonSerializer.Populate()填充JObject中的余数，如下所示：

class MyValuesConverter : CustomPropertyConverterBase<MyValues>
{
    protected override void ProcessCustomProperties(JObject obj, MyValues value, JsonSerializer serializer)
    {
        // Remove the value property for manual deserialization, and deserialize
        var jValue = obj.GetValue("value", StringComparison.OrdinalIgnoreCase).RemoveFromLowestPossibleParent();
        if (jValue != null)
        {
            (value.Values = value.Values ?? new List<Stuff>()).Clear();
            value.Values.Add(jValue.ToObject<Stuff>(serializer));
        }
    }
}

public abstract class CustomPropertyConverterBase<T> : JsonConverter where T : class
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(T).IsAssignableFrom(objectType);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
            return null;
        var jObj = JObject.Load(reader);
        var contract = (JsonObjectContract)serializer.ContractResolver.ResolveContract(objectType);
        var value = existingValue as T ?? (T)contract.DefaultCreator();

        ProcessCustomProperties(jObj, value, serializer);

        // Populate the remaining properties.
        using (var subReader = jObj.CreateReader())
        {
            serializer.Populate(subReader, value);
        }

        return value;
    }

    protected abstract void ProcessCustomProperties(JObject obj, T value, JsonSerializer serializer);

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

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

public static class JsonExtensions
{
    public static JToken RemoveFromLowestPossibleParent(this JToken node)
    {
        if (node == null)
            return null;
        var contained = node.AncestorsAndSelf().Where(t => t.Parent is JContainer && t.Parent.Type != JTokenType.Property).FirstOrDefault();
        if (contained != null)
            contained.Remove();
        // Also detach the node from its immediate containing property -- Remove() does not do this even though it seems like it should
        if (node.Parent is JProperty)
            ((JProperty)node.Parent).Value = null;
        return node;
    }
}

将两个值反序列化为同一属性

2 个答案: