如何使用JSON.NET反序列化爲嵌套/遞歸Dictionary和List？

Question

我需要將複雜的JSON blob反序列化爲標準.NET容器，以便在不知道JSON的代碼中使用。它期望事物處於標準的.NET類型中，特別是Dictionary [string，object]或List [object]，其中「object」可以是原始的或遞歸的（Dictionary或List）。

我不能使用靜態類型來映射結果，並且JObject/JToken不適合。理想情況下，會有某種方式（通過合同）來將原始的JSON轉換爲基本的.NET容器。

我已經搜索過任何方式來哄JSON.NET解串器創建這些簡單的類型時遇到「{}」或「[]」，但很少成功。

任何幫助表示讚賞！

Answer 1

你不能做我在問什麼。至少在我做了很多研究之後我還沒有看到。我不得不編輯Json.NET的源代碼。

Answer 2

通過使用自定義的JsonConverter，您可以完全控制類型的序列化。文檔在http://james.newtonking.com/projects/json/help/html/T_Newtonsoft_Json_JsonConverter.htm。

此外，根據this blog post您需要使用JArray作爲列表，JObject作爲詞典。

Answer 3

我愛AutoMapper並認爲它解決了很多問題......像這樣的......

爲什麼不乾脆讓JSON.NET轉換成任何它想要的東西......和使用AutoMapper將其映射到您真正想要的對象中。

除非性能是最重要的，否則這個額外的步驟應該是值得的，因爲它可以降低複雜性並且可以使用所需的序列化程序。

Answer 4

如果你只是想能夠處理任意JSON並將其轉換成普通.NET類型（原語，列表和字典）的嵌套結構，可以使用JSON.Net的LINQ-to-JSON API做一個通用的方法：

using System.Linq; 
using Newtonsoft.Json.Linq; 

public static class JsonHelper 
{ 
    public static object Deserialize(string json) 
    { 
     return ToObject(JToken.Parse(json)); 
    } 

    private static object ToObject(JToken token) 
    { 
     switch (token.Type) 
     { 
      case JTokenType.Object: 
       return token.Children<JProperty>() 
          .ToDictionary(prop => prop.Name, 
              prop => ToObject(prop.Value)); 

      case JTokenType.Array: 
       return token.Select(ToObject).ToList(); 

      default: 
       return ((JValue)token).Value; 
     } 
    } 
} 

您可以調用如下所示的方法。 obj將包含Dictionary<string, object>,List<object>或原語，具體取決於您開始的JSON。反序列化JSON字符串遞歸到字典和列表與JSON.NET

object obj = JsonHelper.Deserialize(jsonString); 

Answer 5

一種方法是創建一個由JSON.NET提供的JsonConverter抽象類派生的自定義JSON轉換器類。

它是在你的派生的JsonConverter你把實施應如何寫入和從json的對象。

您可以使用自定義的JsonConverter這樣的：

var o = JsonConvert.DeserializeObject<IDictionary<string, object>>(json, new DictionaryConverter()); 

這裏是一個自定義JsonConverter我已經成功在過去使用來實現相同的目標，你在你的問題概括：

public class DictionaryConverter : JsonConverter { 
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { this.WriteValue(writer, value); } 

    private void WriteValue(JsonWriter writer, object value) { 
     var t = JToken.FromObject(value); 
     switch (t.Type) { 
      case JTokenType.Object: 
       this.WriteObject(writer, value); 
       break; 
      case JTokenType.Array: 
       this.WriteArray(writer, value); 
       break; 
      default: 
       writer.WriteValue(value); 
       break; 
     } 
    } 

    private void WriteObject(JsonWriter writer, object value) { 
     writer.WriteStartObject(); 
     var obj = value as IDictionary<string, object>; 
     foreach (var kvp in obj) { 
      writer.WritePropertyName(kvp.Key); 
      this.WriteValue(writer, kvp.Value); 
     } 
     writer.WriteEndObject(); 
    } 

    private void WriteArray(JsonWriter writer, object value) { 
     writer.WriteStartArray(); 
     var array = value as IEnumerable<object>; 
     foreach (var o in array) { 
      this.WriteValue(writer, o); 
     } 
     writer.WriteEndArray(); 
    } 

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { 
     return ReadValue(reader); 
    } 

    private object ReadValue(JsonReader reader) { 
     while (reader.TokenType == JsonToken.Comment) { 
      if (!reader.Read()) throw new JsonSerializationException("Unexpected Token when converting IDictionary<string, object>"); 
     } 

     switch (reader.TokenType) { 
      case JsonToken.StartObject: 
       return ReadObject(reader); 
      case JsonToken.StartArray: 
       return this.ReadArray(reader); 
      case JsonToken.Integer: 
      case JsonToken.Float: 
      case JsonToken.String: 
      case JsonToken.Boolean: 
      case JsonToken.Undefined: 
      case JsonToken.Null: 
      case JsonToken.Date: 
      case JsonToken.Bytes: 
       return reader.Value; 
      default: 
       throw new JsonSerializationException 
        (string.Format("Unexpected token when converting IDictionary<string, object>: {0}", reader.TokenType)); 
     } 
    } 

    private object ReadArray(JsonReader reader) { 
     IList<object> list = new List<object>(); 

     while (reader.Read()) { 
      switch (reader.TokenType) { 
       case JsonToken.Comment: 
        break; 
       default: 
        var v = ReadValue(reader); 

        list.Add(v); 
        break; 
       case JsonToken.EndArray: 
        return list; 
      } 
     } 

     throw new JsonSerializationException("Unexpected end when reading IDictionary<string, object>"); 
    } 

    private object ReadObject(JsonReader reader) { 
     var obj = new Dictionary<string, object>(); 

     while (reader.Read()) { 
      switch (reader.TokenType) { 
       case JsonToken.PropertyName: 
        var propertyName = reader.Value.ToString(); 

        if (!reader.Read()) { 
         throw new JsonSerializationException("Unexpected end when reading IDictionary<string, object>"); 
        } 

        var v = ReadValue(reader); 

        obj[propertyName] = v; 
        break; 
       case JsonToken.Comment: 
        break; 
       case JsonToken.EndObject: 
        return obj; 
      } 
     } 

     throw new JsonSerializationException("Unexpected end when reading IDictionary<string, object>"); 
    } 

    public override bool CanConvert(Type objectType) { return typeof(IDictionary<string, object>).IsAssignableFrom(objectType); } 
} 

這裏是f#等價的：

type IDictionaryConverter() = 
    inherit JsonConverter() 

    let rec writeValue (writer: JsonWriter) (value: obj) = 
      let t = JToken.FromObject(value) 
      match t.Type with 
      | JTokenType.Object -> writeObject writer value 
      | JTokenType.Array -> writeArray writer value 
      | _ -> writer.WriteValue value  

    and writeObject (writer: JsonWriter) (value: obj) = 
     writer.WriteStartObject() 
     let obj = value :?> IDictionary<string, obj> 
     for kvp in obj do 
      writer.WritePropertyName kvp.Key 
      writeValue writer kvp.Value 
     writer.WriteEndObject()  

    and writeArray (writer: JsonWriter) (value: obj) = 
     writer.WriteStartArray() 
     let array = value :?> IEnumerable<obj> 
     for o in array do 
      writeValue writer o 
     writer.WriteEndArray() 

    let rec readValue (reader: JsonReader) = 
     while reader.TokenType = JsonToken.Comment do 
      if reader.Read() |> not then raise (JsonSerializationException("Unexpected token when reading object")) 

     match reader.TokenType with 
     | JsonToken.Integer 
     | JsonToken.Float 
     | JsonToken.String 
     | JsonToken.Boolean 
     | JsonToken.Undefined 
     | JsonToken.Null 
     | JsonToken.Date 
     | JsonToken.Bytes -> reader.Value 
     | JsonToken.StartObject -> readObject reader Map.empty 
     | JsonToken.StartArray -> readArray reader [] 
     | _ -> raise (JsonSerializationException(sprintf "Unexpected token when reading object: %O" reader.TokenType)) 


    and readObject (reader: JsonReader) (obj: Map<string, obj>) = 
     match reader.Read() with 
     | false -> raise (JsonSerializationException("Unexpected end when reading object")) 
     | _ -> reader.TokenType |> function 
      | JsonToken.Comment -> readObject reader obj 
      | JsonToken.PropertyName -> 
       let propertyName = reader.Value.ToString() 
       if reader.Read() |> not then raise (JsonSerializationException("Unexpected end when reading object")) 
       let value = readValue reader 
       readObject reader (obj.Add(propertyName, value)) 
      | JsonToken.EndObject -> box obj 
      | _ -> raise (JsonSerializationException(sprintf "Unexpected token when reading object: %O" reader.TokenType)) 

    and readArray (reader: JsonReader) (collection: obj list) = 
     match reader.Read() with 
     | false -> raise (JsonSerializationException("Unexpected end when reading array")) 
     | _ -> reader.TokenType |> function 
      | JsonToken.Comment -> readArray reader collection 
      | JsonToken.EndArray -> box collection 
      | _ -> collection @ [readValue reader] |> readArray reader 

    override __.CanConvert t = (typeof<IDictionary<string, obj>>).IsAssignableFrom t 
    override __.WriteJson (writer:JsonWriter, value: obj, _:JsonSerializer) = writeValue writer value 
    override __.ReadJson (reader:JsonReader, _: Type, _:obj, _:JsonSerializer) = readValue reader