Jak mogę iterować zagnieżdżone słowniki za pomocą JSON.NET?

Question

Mam strukturę JSON, którą chciałbym ręcznie analizować do obiektu POCO przy użyciu JSON.NET.

Struktura JSON jest zbiorem zagnieżdżonych słowników ... Słownik główny zawiera kategorie, następny poziom zawiera produkty w tych kategoriach, a na ostatnim poziomie znajdują się wersje tych produktów.

{ 
     "category-1": { 
      "product-1": { 
       "product-version-1": { 
        "id":1, 
        ... 
       } 
      } 
     }, 
     "category-2": { 
      "product-2": { 
       "product-version-2": { 
        "id":2, 
        ... 
       } 
      }, 
      "product-3": { 
       "product-version-3": { 
        "id":3, 
        ... 
       } 
      } 
     } 
} 

chciałbym analizować tę strukturę, pamiętając klucze wszystkich słowników nie są mi znane z wyprzedzeniem.

To był kod, który napisałem (miałem zamiar przekonwertować na LINQ po uruchomieniu ...) - Spodziewałem się, że to zadziała z kilkoma zagnieżdżonymi pętlami, ale wyraźnie JTokens i JObjects nie działają tak, jak to Myślałem ... Id jest zawsze zerowy.

var productsJObject = JObject.Parse(result.Content.ReadAsStringAsync().Result); 

foreach (var category in productsJObject) 
{ 
    foreach (var product in category.Value) 
    { 
     foreach (var version in product) 
     { 
      var poco = new Poco 
         { 
          Id = version.SelectToken("id").ToString() 
         }; 
     } 
    } 
} 

Moje pytanie brzmi: jak mogę iterować za pomocą zagnieżdżonych słowników przy użyciu JSON.Net?

Answer 1

Znaleziono to pytanie próbując dowiedzieć się, jak parsować JSON.NET w języku C#. Mam nadzieję, że moja odpowiedź pomoże komuś innemu ...

Napisałem ten kod, aby pomóc mi parsować losowy obiekt JSON i analizować strukturę. Jest dość szorstki i prawdopodobnie nie obsługuje wszystkich scenariuszy, ale robi to. Teraz jest to po prostu miejsce przechowywania w słowniku, ale powinno być dość łatwo zobaczyć, co robi i zmodyfikować, aby zrobić to, co chcesz:

static void Main(string[] args) 
{ 
    Dictionary<string, string> nodes = new Dictionary<string, string>(); 

    // put your JSON object here 
    JObject rootObject = JObject.Parse("{\"world\": {\"hello\": \"woo\", \"foo\": \"bar\", \"arr\": [\"one\", \"two\"]}}"); 

    ParseJson(rootObject, nodes); 

    // nodes dictionary contains xpath-like node locations 
    Debug.WriteLine(""); 
    Debug.WriteLine("JSON:"); 
    foreach (string key in nodes.Keys) 
    { 
     Debug.WriteLine(key + " = " + nodes[key]); 
    } 
} 

/// <summary> 
/// Parse a JSON object and return it as a dictionary of strings with keys showing the heirarchy. 
/// </summary> 
/// <param name="token"></param> 
/// <param name="nodes"></param> 
/// <param name="parentLocation"></param> 
/// <returns></returns> 
public static bool ParseJson(JToken token, Dictionary<string, string> nodes, string parentLocation = "") 
{ 
    if (token.HasValues) 
    { 
     foreach (JToken child in token.Children()) 
     { 
      if (token.Type == JTokenType.Property) 
       parentLocation += "/" + ((JProperty)token).Name; 
      ParseJson(child, nodes, parentLocation); 
     } 

     // we are done parsing and this is a parent node 
     return true; 
    } 
    else 
    { 
     // leaf of the tree 
     if (nodes.ContainsKey(parentLocation)) 
     { 
      // this was an array 
      nodes[parentLocation] += "|" + token.ToString(); 
     } 
     else 
     { 
      // this was a single property 
      nodes.Add(parentLocation, token.ToString()); 
     } 

     return false; 
    } 
}