मैं JSON.NET के साथ नेस्टेड शब्दकोशों के माध्यम से कैसे पुन: प्रयास कर सकता हूं?

Question

मेरे पास एक JSON संरचना है जो मैं JSON.NET का उपयोग कर POCO ऑब्जेक्ट को मैन्युअल रूप से पार्स करना चाहता हूं।

JSON संरचना नेस्टेड शब्दकोशों का एक समूह है ... रूट शब्दकोश में श्रेणियां हैं, अगले स्तर में उन श्रेणियों के भीतर उत्पाद शामिल हैं और अंतिम स्तर में उन उत्पादों के संस्करण शामिल हैं।

{ 
     "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, 
        ... 
       } 
      } 
     } 
} 

मैं इस संरचना पार्स करने के लिए, मन में सभी शब्दकोशों की चाबी रखने मेरे लिए समय से आगे नहीं जाना जाता है चाहते हैं।

यह वह कोड था जिसे मैंने लिखा था (मैं इसे काम करने के बाद LINQ में परिवर्तित करने जा रहा था ...) - मुझे उम्मीद थी कि यह दो घोंसले वाले लूपों के साथ काम करेगी लेकिन स्पष्ट रूप से जेटीकेन्स और जॉब्जेक्ट्स काम नहीं करते हैं मैंने सोचा ... आईडी हमेशा शून्य है।

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() 
         }; 
     } 
    } 
} 

तो मेरा सवाल है, मैं JSON.Net का उपयोग करके नेस्टेड शब्दकोशों में कैसे पुन: प्रयास कर सकता हूं?

Answer 1

यह प्रश्न यह पता लगाने की कोशिश कर रहा है कि सी # में JSON.NET को कैसे पार्स करें। उम्मीद है कि मेरा जवाब किसी और की मदद करेगा ...

मैंने इस कोड को एक यादृच्छिक JSON ऑब्जेक्ट को पार्स करने और संरचना का विश्लेषण करने में मदद करने के लिए लिखा था। यह कुछ हद तक मोटा है और शायद सभी परिदृश्यों को संभाल नहीं करता है, लेकिन यह चाल है। अभी यह सिर्फ एक शब्दकोश में स्थानों को संग्रहीत कर रहा है, लेकिन यह देखना बहुत आसान होना चाहिए कि आप क्या कर रहे हैं और इसे करने के लिए इसे संशोधित करना चाहिए:

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; 
    } 
}