如何使用自定义 JsonConverter 仅反序列化 Json.NET 中的子对象？

Question

我想从网络响应中反序列化 JSON。这是一个典型的回应：

{
    "response": {
        "garbage": 0,
        "details": [
            {
                "id": "123456789"
            }
        ]
    }
}

但是，这种格式是不可取的。理想情况下，响应只是

{
    "id": "123456789"
}

这样它就可以反序列化成一个像

这样的对象

public class Details {
    [JsonProperty("id")]
    public ulong Id { get; set; }
}

由于我无法控制服务器（它是一个公共 API），我的目标是修改反序列化过程以实现我想要的格式。

---

我尝试使用自定义JsonConverter 来完成此操作。这个想法是跳过令牌，直到我找到反序列化到Details 的所需起点。但是，我不确定在反序列化过程中应该在哪里使用它。

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Newtonsoft.Json;

namespace ConsoleApp2 {
    class Program {
        static void Main(string[] args) {
            // Simulating a stream from WebResponse.
            const string json = "{"response":{"garbage":0,"details":[{"id":"123456789"}]}}";
            byte[] bytes = System.Text.Encoding.UTF8.GetBytes(json);
            Stream stream = new MemoryStream(bytes);

            Details details = Deserialise<Details>(stream);

            Console.WriteLine($"ID: {details.Id}");
            Console.Read();
        }

        public static T Deserialise<T>(Stream stream) where T : class {
            using (StreamReader reader = new StreamReader(stream, Encoding.UTF8)) {
                JsonSerializerSettings settings = new JsonSerializerSettings {
                    MissingMemberHandling = MissingMemberHandling.Ignore,
                    DateParseHandling = DateParseHandling.None
                };

                settings.Converters.Add(new DetailConverter());
                return JsonSerializer.Create(settings).Deserialize(reader, typeof(T)) as T;
            }
        }
    }

    public class Details {
        [JsonProperty("id")]
        public ulong Id { get; set; }
    }

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

        public override object ReadJson(JsonReader reader,
                                        Type objectType,
                                        object existingValue,
                                        JsonSerializer serializer) {
            if (reader.Depth == 0) {
                while (!(reader.Path.Equals("response.details[0]", StringComparison.OrdinalIgnoreCase) && reader.TokenType == JsonToken.StartObject)) {
                    reader.Read();
                }

                try {
                    return serializer.Deserialize(reader, objectType);
                } finally {
                    reader.Read(); // EndArray - details
                    reader.Read(); // EndObject - response
                    reader.Read(); // EndObject - root
                }
            }

            return serializer.Deserialize(reader, objectType);
        }

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

就目前的情况而言，堆栈溢出是因为DetailConverter.ReadJson() 被反复用于同一个对象，并且它永远不会被反序列化。我认为这是因为我通过JsonSerializerSettings 将DetailConverter 设置为“全局”转换器。我认为问题在于何时以及如何使用我的转换器，而不是其内部工作原理。

---

我得到了一个类似的DetailConverter 来为以下结构工作。但是，虽然 details 中的数组已被删除，但由于嵌套和未使用的属性，它仍然是不可取的。

public class Root {
    [JsonProperty("response")]
    public Response Response { get; set; }
}

public class Response {
    [JsonProperty("details")]
    [JsonConverter(typeof(DetailConverter))]
    public Details Details { get; set; }

    [JsonProperty("garbage")]
    public uint Garbage { get; set; }
}

public class Details {
    [JsonProperty("id")]
    public ulong Id { get; set; }
}

我认为将转换器扩展到整个 JSON 而不仅仅是一个属性会很简单。我哪里做错了？

Answer 1

Linq to JSON 是否适合您？

using System;
using Newtonsoft.Json.Linq;

public class Program
{
    public static void Main()
    {
        var json = "{'response':{'garbage':0,'details':[{'id':'123456789'}]}}";
        var obj = JObject.Parse(json);
        var details = obj["response"]["details"];

        Console.WriteLine(details);
    }
}

Answer 2

看起来你想要一个来自 details 数组的单个值，所以我的回答只是第一个。像这样的转换器会工作吗？它获取 JObject 并从 details 数组中挑选出一个值，然后将其转换为 Details 类。

public class DetailsConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(Details) == objectType;
    }

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

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var obj = JObject.Load(reader);
        var value = obj["response"]?["details"]?.FirstOrDefault();
        if (value == null) { return null; }
        return value.ToObject<Details>();
    }

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

当你使用序列化器时，你可以简单地这样调用它：

var details = JsonConvert.DeserializeObject<Details>(json, settings);

请注意，您需要创建JsonSerializerSettings settings，并在设置对象的Converters列表中包含DetailsConverter。

Answer 3

解决方案是在我的JsonConverter 调用JsonSerializer.Deserialize 之前清除JsonSerializer 的转换器列表。

我从here 得到了这个想法，其中一位用户描述了将JsonContract 的JsonConverter 置零如何恢复为默认的JsonConverter。这避免了为我希望反序列化的子对象重复调用我的自定义 JsonConverter 的问题。

public override object ReadJson(JsonReader reader,
                                Type objectType,
                                object existingValue,
                                JsonSerializer serializer) {
    while (reader.Depth != 3) {
        reader.Read();
    }

    serializer.Converters.Clear();

    return serializer.Deserialize(reader, objectType);
}

代码也得到了简化，删除了 try - finally 块。没有必要读取结束标记，因为无论如何都不会尝试反序列化它们。也无需检查深度，因为自定义的JsonConverter 只会使用一次。