JSON को C # डायनामिक ऑब्जेक्ट में बताएं?


965

क्या JSON सामग्री को C # 4 डायनामिक प्रकार में डिसेर्बलाइज़ करने का कोई तरीका है? इसका उपयोग करने के लिए कक्षाओं का एक समूह बनाना छोड़ना अच्छा होगा DataContractJsonSerializer


5
यदि आप कुछ 'डायनेमिक' चाहते हैं, तो अधिकांश JSON डिकोडर्स के साथ आने वाले गेट-स्टाइल एक्सेसर्स का उपयोग क्यों न करें, जो सादे-पुराने ऑब्जेक्ट पर नहीं जाते हैं? (उदाहरण के लिए वास्तव में 'गतिशील' ऑब्जेक्ट निर्माण की आवश्यकता है?) json.org में C # JSON कार्यान्वयन के लिए लिंक का एक गुच्छा है।

मैं एक ऐसी परियोजना पर काम कर रहा हूं जो बाहरी निर्भरता को न्यूनतम रखने की कोशिश कर रही है। तो अगर यह शेयर .net serializers और प्रकार है कि पसंद किया जाएगा के साथ कुछ करने के लिए संभव है। बेशक अगर यह संभव नहीं है तो मैं json.org मार रहा हूं। धन्यवाद!
जिंसन

42
मुझे वास्तव में आश्चर्य हुआ कि C # टीम ने 'डायनामिक' जोड़ा, लेकिन तब CLR में JSON ऑब्जेक्ट को डायनेमिक CLR क्लास इंस्टेंस में बदलने का कोई तरीका नहीं है।
फ्रैंक श्वेतेरमैन

2
दुर्भाग्य से स्वीकृत उत्तर .NET 4 RTM में काम नहीं करता है। मैंने एक उत्तर पोस्ट किया जिसने मुझे इस के साथ जाने में मदद की जो दूसरों के लिए उपयोगी हो सकता है।
ड्रू नोकें

(हालांकि ऐसा प्रतीत होता है कि न्यूटनसॉफ्ट JSON.NET बहुत करीब आता है। हालांकि, वास्तव में कोई भी अच्छे उदाहरण नहीं हैं।)
हॉट लक्स

जवाबों:


659

यदि आप System.Web.Helpersविधानसभा पर निर्भरता से खुश हैं , तो आप Jsonवर्ग का उपयोग कर सकते हैं :

dynamic data = Json.Decode(json);

इसे MVC फ्रेमवर्क के साथ .NET 4 फ्रेमवर्क के अतिरिक्त डाउनलोड के रूप में शामिल किया गया है । अगर मददगार हो तो व्लाद को अपवोट देना सुनिश्चित करें! हालाँकि, यदि आप क्लाइंट वातावरण को इस DLL में शामिल नहीं कर सकते हैं, तो पढ़ें।


एक वैकल्पिक deserialisation दृष्टिकोण यहाँ सुझाया गया है । मैंने बग को ठीक करने और अपनी कोडिंग शैली के अनुरूप कोड को थोड़ा संशोधित किया। आप सभी की जरूरत है इस कोड और System.Web.Extensionsअपनी परियोजना से एक संदर्भ है :

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Web.Script.Serialization;

public sealed class DynamicJsonConverter : JavaScriptConverter
{
    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    {
        if (dictionary == null)
            throw new ArgumentNullException("dictionary");

        return type == typeof(object) ? new DynamicJsonObject(dictionary) : null;
    }

    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override IEnumerable<Type> SupportedTypes
    {
        get { return new ReadOnlyCollection<Type>(new List<Type>(new[] { typeof(object) })); }
    }

    #region Nested type: DynamicJsonObject

    private sealed class DynamicJsonObject : DynamicObject
    {
        private readonly IDictionary<string, object> _dictionary;

        public DynamicJsonObject(IDictionary<string, object> dictionary)
        {
            if (dictionary == null)
                throw new ArgumentNullException("dictionary");
            _dictionary = dictionary;
        }

        public override string ToString()
        {
            var sb = new StringBuilder("{");
            ToString(sb);
            return sb.ToString();
        }

        private void ToString(StringBuilder sb)
        {
            var firstInDictionary = true;
            foreach (var pair in _dictionary)
            {
                if (!firstInDictionary)
                    sb.Append(",");
                firstInDictionary = false;
                var value = pair.Value;
                var name = pair.Key;
                if (value is string)
                {
                    sb.AppendFormat("{0}:\"{1}\"", name, value);
                }
                else if (value is IDictionary<string, object>)
                {
                    new DynamicJsonObject((IDictionary<string, object>)value).ToString(sb);
                }
                else if (value is ArrayList)
                {
                    sb.Append(name + ":[");
                    var firstInArray = true;
                    foreach (var arrayValue in (ArrayList)value)
                    {
                        if (!firstInArray)
                            sb.Append(",");
                        firstInArray = false;
                        if (arrayValue is IDictionary<string, object>)
                            new DynamicJsonObject((IDictionary<string, object>)arrayValue).ToString(sb);
                        else if (arrayValue is string)
                            sb.AppendFormat("\"{0}\"", arrayValue);
                        else
                            sb.AppendFormat("{0}", arrayValue);

                    }
                    sb.Append("]");
                }
                else
                {
                    sb.AppendFormat("{0}:{1}", name, value);
                }
            }
            sb.Append("}");
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            if (!_dictionary.TryGetValue(binder.Name, out result))
            {
                // return null to avoid exception.  caller can check for null this way...
                result = null;
                return true;
            }

            result = WrapResultObject(result);
            return true;
        }

        public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
        {
            if (indexes.Length == 1 && indexes[0] != null)
            {
                if (!_dictionary.TryGetValue(indexes[0].ToString(), out result))
                {
                    // return null to avoid exception.  caller can check for null this way...
                    result = null;
                    return true;
                }

                result = WrapResultObject(result);
                return true;
            }

            return base.TryGetIndex(binder, indexes, out result);
        }

        private static object WrapResultObject(object result)
        {
            var dictionary = result as IDictionary<string, object>;
            if (dictionary != null)
                return new DynamicJsonObject(dictionary);

            var arrayList = result as ArrayList;
            if (arrayList != null && arrayList.Count > 0)
            {
                return arrayList[0] is IDictionary<string, object> 
                    ? new List<object>(arrayList.Cast<IDictionary<string, object>>().Select(x => new DynamicJsonObject(x))) 
                    : new List<object>(arrayList.Cast<object>());
            }

            return result;
        }
    }

    #endregion
}

आप इसे इस तरह से उपयोग कर सकते हैं:

string json = ...;

var serializer = new JavaScriptSerializer();
serializer.RegisterConverters(new[] { new DynamicJsonConverter() });

dynamic obj = serializer.Deserialize(json, typeof(object));

तो, एक JSON स्ट्रिंग दिया:

{
  "Items":[
    { "Name":"Apple", "Price":12.3 },
    { "Name":"Grape", "Price":3.21 }
  ],
  "Date":"21/11/2010"
}

निम्न कोड रनटाइम पर काम करेगा:

dynamic data = serializer.Deserialize(json, typeof(object));

data.Date; // "21/11/2010"
data.Items.Count; // 2
data.Items[0].Name; // "Apple"
data.Items[0].Price; // 12.3 (as a decimal)
data.Items[1].Name; // "Grape"
data.Items[1].Price; // 3.21 (as a decimal)

1
मुझे गतिशील obj = serializer.Deserialize (json, typeof (ऑब्जेक्ट)) में एक त्रुटि मिलती है; कह रही है कि 2 तर्कों के साथ विधि के लिए कोई अधिभार नहीं है। dll या क्या?
स्टिव ग्रिफ़िन

32
आप System.Web.Helpers.Json का उपयोग कर सकते हैं - यह एक डायोड विधि प्रदान करता है जो एक गतिशील वस्तु देता है। मैंने इस जानकारी को उत्तर के रूप में भी पोस्ट किया है।
व्लाद Iliescu

2
इसने मुझे बहुत मदद की, लेकिन मैं उत्सुक हूं कि मुझे क्या करना चाहिए अगर मुझे इसका उपयोग करने की आवश्यकता है। विधि का उपयोग करें, जो वर्तमान में केवल एक NotImplementedException फेंकता है ... मैं सील वर्गों और / या विस्तारित सार से परिचित नहीं हूं कक्षाएं। क्या कोई मुझे सही दिशा दिखा सकता है?
Cory डब्ल्यू।

2
कभी-कभी js में आपके पास "पृष्ठभूमि-रंग" जैसे विशेष वर्ण वाले फ़ील्ड होते हैं। Js में ऐसे फ़ील्ड्स तक पहुँचने के लिए आप obj ["बैकग्राउंड-कलर"] करते हैं। डायनामिक ऑब्जेक्ट के डीरियलाइज़ करने के बाद मैं c # से ऐसे फ़ील्ड्स तक कैसे पहुँच सकता हूँ? मैं obj.background- रंग नहीं कर सकता, ज़ाहिर है, और obj ["पृष्ठभूमि-रंग"] काम करने के लिए प्रतीत नहीं होता है। अच्छा होगा यदि डायनेमिक ऑब्जेक्ट को डिक्शनरी के रूप में एक्सेस किया जा सकता है, उसी समय, जैसे js में।
राडु सिमियोनेस्कु

2
@RaduSimionescu मुझे शायद थोड़ी देर हो गई है, लेकिन शायद यह भविष्य के आगंतुकों की मदद करता है। मुझे एक ही समस्या थी, बस फ़ील्ड-नाम params(जो कि C # में एक कीवर्ड है) के साथ। इसके अलावा TryGetMemberआप ओवरराइड कर सकते हैं TryGetIndex, जो आपको जेएस की तरह ही व्यवहार देता है। फिर आप अजीब क्षेत्र नामों के लिए obj["params"]या कर सकते हैं obj["background-color"]
मार्टिन एंडर

606

यह Json.NET का उपयोग करके बहुत सरल है :

dynamic stuff = JsonConvert.DeserializeObject("{ 'Name': 'Jon Smith', 'Address': { 'City': 'New York', 'State': 'NY' }, 'Age': 42 }");

string name = stuff.Name;
string address = stuff.Address.City;

इसके अलावा using Newtonsoft.Json.Linq:

dynamic stuff = JObject.Parse("{ 'Name': 'Jon Smith', 'Address': { 'City': 'New York', 'State': 'NY' }, 'Age': 42 }");

string name = stuff.Name;
string address = stuff.Address.City;

प्रलेखन: गतिशील के साथ JSON क्वेरी


9
@HotLicks: गतिशील आत्मनिरीक्षण करने के stuffलिए कुछ इस तरह करें:foreach (Newtonsoft.Json.Linq.JProperty jproperty in stuff) { Console.WriteLine("jproperty.Name = {0}", jproperty.Name);}
Matthias

11
JsonConvert.DeserializeObject और JObject.Parse के बीच क्या अंतर है? जवाब उन दोनों को एक ही तरह से एक ही काम करने के लिए उपयोग कर रहा है लेकिन अंतर नहीं बताता है।
cja

7
@TomPeplow ने इसकी कोशिश की। यह मेरे लिए काम नहीं किया। इसमें कहा गया है कि "जोबजेक्ट 'नाम' को लागू नहीं करता है।"
ली लुईविरे

4
@ cja कोई अंतर नहीं: stackoverflow.com/questions/23645034/…
nawfal

7
मैं यह काम करने के लिए नहीं मिल सकता। मैंने एक asyncविधि के अंदर होने के लिए समस्या को कम कर दिया है । यदि मैं विधि को समकालिक बनाता हूं तो यह अपेक्षा के अनुरूप काम करता है। हालाँकि, विधि बनाओ asyncऔर मैं एक नहीं मिल सकता है dynamic, मैं बस एक मिलता है object। स्पष्ट कास्टिंग कुछ भी नहीं करता है, अभी भी मुझे एक देता है object। क्या कोई अन्य इसका अनुभव ले रहा है?
कोडकॉनसियन

295

आप इसे System.Web.Helpers.Json का उपयोग करके कर सकते हैं - इसकी डिकोड विधि एक गतिशील वस्तु लौटाती है जिसे आप पसंद करते हैं।

यह System.Web.Helpers असेंबली (.NET 4.0) में शामिल है।

var dynamicObject = Json.Decode(jsonString);

25
FYI करें। System .eb.Helpers.dll को .net 4.0 की आवश्यकता है, लेकिन .net 4.0 में शामिल नहीं है। इसे ASP.NET MVC 3
jbtule

7
विजुअल स्टूडियो 2012 में असेंबली के तहत एक्सटेंशन्स समूह में आपको यह असेंबली
मिलेगी

1
गतिशील का उपयोग करने के साथ कोई समस्या? अगर इनपुट JSON में गुण नहीं हैं तो हम कुशलता से अपवादों को कैसे संभाल सकते हैं ..
उस्मा खलील

5
यदि आप मॉडल को दृढ़ता से टाइप करना चाहते हैं तो Json.Decode <T> (string) विधि का उपयोग करना सुनिश्चित करें।
माइक

2
अपनी परियोजना में इस पुस्तकालय को जोड़ने के लिए: stackoverflow.com/questions/8037895/…

80

.NET 4.0 के पास ऐसा करने के लिए एक अंतर्निहित लाइब्रेरी है:

using System.Web.Script.Serialization;
JavaScriptSerializer jss = new JavaScriptSerializer();
var d = jss.Deserialize<dynamic>(str);

यह सबसे सरल तरीका है।


27
क्या आपने यह कोशिश की है? यह लौट आता है Dictionary<string,object>। जब तक मैं कुछ याद नहीं कर रहा हूं, आपका उदाहरण एक गतिशील वस्तु नहीं लौटाता है।
सेरगोपेरेरा

18
यह काम नहीं करता है, यह सिर्फ
मैटमनर

55
@ पैटर लोंग मुझे विश्वास है कि मैं अपने मामले को स्पष्ट रूप से बताने में विफल रहा हूं, प्रिय साथी। मुझे अपनी त्रुटि सुधारने का प्रयास करने दीजिए। मुझे पता है कि एक गतिशील क्या है। यह आपको JSON ऑब्जेक्ट में पास होने और d.code का उपयोग करने की अनुमति नहीं देता है, आपको d ["कोड"] करना होगा। मान, जो इस उत्तर को खोजने वाले अधिकांश लोग नहीं चाहते हैं, हम पहले से ही जानते हैं कि कैसे करना है। शब्दकोश प्राप्त करें और इसे एक गतिशील के लिए कास्टिंग समय की कुल बर्बादी है। मैं आदरपूर्वक असहमत हूं, सर।
मैटमनर

4
@mattmanser, we already know how to get the dictionary and casting it to a dynamic। इसके लिए डिक्शन नहीं होना चाहिए। Json में डिक्शनरी के अलावा लिस्ट भी हैं। और सूचियों और शब्दकोशों को भी नेस्टेड किया जा सकता है। मेरा कोड इन सभी स्थितियों को संभाल सकता है। लेकिन आपका तरीका नहीं हो सकता।
पीटर लॉन्ग

4
@ मट्टमनसर सही है; इसे लागू करना IDynamicMetaObjectProvider(या उदाहरण के लिए उपयोग करना ExpandoObject) संभव है जो गुणों को अवरोधन करने और उन्हें एक आंतरिक शब्दकोश में देखने में सक्षम हो। यह dynamicअनुमति देता कोड के उपयोग के साथ संयुक्त रूप d.codeसे इस्तेमाल किया जा सकता है। किसी डिक्शनरी को डिक्शनरी में डालना व्यर्थ है।
स्टीफन ड्रू

78

किसी भी तृतीय-पक्ष DLL फ़ाइल के बिना ऑब्जेक्ट के लिए सरल "स्ट्रिंग JSON डेटा":

WebClient client = new WebClient();
string getString = client.DownloadString("https://graph.facebook.com/zuck");

JavaScriptSerializer serializer = new JavaScriptSerializer();
dynamic item = serializer.Deserialize<object>(getString);
string name = item["name"];

//note: JavaScriptSerializer in this namespaces
//System.Web.Script.Serialization.JavaScriptSerializer

नोट: आप अपने कस्टम ऑब्जेक्ट का उपयोग भी कर सकते हैं।

Personel item = serializer.Deserialize<Personel>(getString);

4
आईडी नहीं मिली। यह अब तक का सबसे सरल उपाय है और कोई भी इसका उल्लेख नहीं करता है।
cikatomo

2
हाँ यह आसान है :) कभी-कभी आपको सीरियलाइज़ करने की ज़रूरत होती है, लेकिन तीसरे भाग को शामिल नहीं करना चाहते हैं
imbrahim Özbölük

क्या आप इस बारे में विस्तार से बता सकते हैं: डायसेरलाइज्ड ऑब्जेक्ट को किस माध्यम से एक्सेस किया जा सकता है myObject["myprop"]? मुझे पता है कि यह रनटाइम पर किया गया है, लेकिन इसके माध्यम से एक्सेस करना कैसे myObject["myprop"]मान्य है?
रॉय नामी

1
आप अपनी वस्तु को कार्मिक मद = क्रमादेशक की तरह डीरियलाइज़ कर सकते हैं। डिजायराइज़ करें <कार्मिक> (गेटस्ट्रिंग); और अगर आप डायनेमिक ऑब्जेक्ट का उपयोग करते हैं, तो आप एरे का उपयोग कर सकते हैं और सब कुछ संभव है जैसे कि सबोबिज
imbrahim ükzbölük

3
System.Web.Script.Serialization नामस्थान का उपयोग करने के लिए आपके प्रोजेक्ट को System.Web.Extensions का संदर्भ चाहिए।
स्टिलगारिस्का 12

28

JsonFx गतिशील वस्तुओं में JSON सामग्री को निष्क्रिय कर सकता है।

डायनामिक प्रकारों से / से अनुक्रमित करें (.NET 4.0 के लिए डिफ़ॉल्ट):

var reader = new JsonReader(); var writer = new JsonWriter();

string input = @"{ ""foo"": true, ""array"": [ 42, false, ""Hello!"", null ] }";
dynamic output = reader.Read(input);
Console.WriteLine(output.array[0]); // 42
string json = writer.Write(output);
Console.WriteLine(json); // {"foo":true,"array":[42,false,"Hello!",null]}

19

मैंने डायनेमिकजोनकोर्टर का एक नया संस्करण बनाया है जो एक्सपेंडेओ ऑब्जेक्ट्स का उपयोग करता है। मैंने एक्सपेंडो ऑब्जेक्ट्स का उपयोग किया, क्योंकि मैं JSON.NET का उपयोग करके डायनामिक बैक को JSON में सीरियल करना चाहता था।

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Dynamic;
using System.Web.Script.Serialization;

public static class DynamicJson
{
    public static dynamic Parse(string json)
    {
        JavaScriptSerializer jss = new JavaScriptSerializer();
        jss.RegisterConverters(new JavaScriptConverter[] { new DynamicJsonConverter() });

        dynamic glossaryEntry = jss.Deserialize(json, typeof(object)) as dynamic;
        return glossaryEntry;
    }

    class DynamicJsonConverter : JavaScriptConverter
    {
        public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            if (dictionary == null)
                throw new ArgumentNullException("dictionary");

            var result = ToExpando(dictionary);

            return type == typeof(object) ? result : null;
        }

        private static ExpandoObject ToExpando(IDictionary<string, object> dictionary)
        {
            var result = new ExpandoObject();
            var dic = result as IDictionary<String, object>;

            foreach (var item in dictionary)
            {
                var valueAsDic = item.Value as IDictionary<string, object>;
                if (valueAsDic != null)
                {
                    dic.Add(item.Key, ToExpando(valueAsDic));
                    continue;
                }
                var arrayList = item.Value as ArrayList;
                if (arrayList != null && arrayList.Count > 0)
                {
                    dic.Add(item.Key, ToExpando(arrayList));
                    continue;
                }

                dic.Add(item.Key, item.Value);
            }
            return result;
        }

        private static ArrayList ToExpando(ArrayList obj)
        {
            ArrayList result = new ArrayList();

            foreach (var item in obj)
            {
                var valueAsDic = item as IDictionary<string, object>;
                if (valueAsDic != null)
                {
                    result.Add(ToExpando(valueAsDic));
                    continue;
                }

                var arrayList = item as ArrayList;
                if (arrayList != null && arrayList.Count > 0)
                {
                    result.Add(ToExpando(arrayList));
                    continue;
                }

                result.Add(item);
            }
            return result;
        }

        public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            throw new NotImplementedException();
        }

        public override IEnumerable<Type> SupportedTypes
        {
            get { return new ReadOnlyCollection<Type>(new List<Type>(new[] { typeof(object) })); }
        }
    }
}


14

आप न्यूटनसॉफ्ट की मदद से इसे प्राप्त कर सकते हैं। Json। Nuget से Newtonsoft.Json स्थापित करें और:

using Newtonsoft.Json;

dynamic results = JsonConvert.DeserializeObject<dynamic>(YOUR_JSON);

8

सबसे सरल तरीका है:

बस इस DLL फ़ाइल को शामिल करें ।

इस तरह कोड का उपयोग करें:

dynamic json = new JDynamic("{a:'abc'}");
// json.a is a string "abc"

dynamic json = new JDynamic("{a:3.1416}");
// json.a is 3.1416m

dynamic json = new JDynamic("{a:1}");
// json.a is

dynamic json = new JDynamic("[1,2,3]");
/json.Length/json.Count is 3
// And you can use json[0]/ json[2] to get the elements

dynamic json = new JDynamic("{a:[1,2,3]}");
//json.a.Length /json.a.Count is 3.
// And you can use  json.a[0]/ json.a[2] to get the elements

dynamic json = new JDynamic("[{b:1},{c:1}]");
// json.Length/json.Count is 2.
// And you can use the  json[0].b/json[1].c to get the num.

6

आप जावास्क्रिप्ट को विस्तारक ऑब्जेक्ट (ओं) के लिए बनाए गए शब्दकोश को फिर से कॉपी करने और फिर उन्हें गतिशील रूप से उपयोग करने के लिए JavaScriptSerializer का विस्तार कर सकते हैं:

static class JavaScriptSerializerExtensions
{
    public static dynamic DeserializeDynamic(this JavaScriptSerializer serializer, string value)
    {
        var dictionary = serializer.Deserialize<IDictionary<string, object>>(value);
        return GetExpando(dictionary);
    }

    private static ExpandoObject GetExpando(IDictionary<string, object> dictionary)
    {
        var expando = (IDictionary<string, object>)new ExpandoObject();

        foreach (var item in dictionary)
        {
            var innerDictionary = item.Value as IDictionary<string, object>;
            if (innerDictionary != null)
            {
                expando.Add(item.Key, GetExpando(innerDictionary));
            }
            else
            {
                expando.Add(item.Key, item.Value);
            }
        }

        return (ExpandoObject)expando;
    }
}

तब आपको केवल उन नामस्थानों के लिए एक स्टेटमेंट का उपयोग करने की आवश्यकता होती है जिन्हें आपने एक्सटेंशन में परिभाषित किया था (केवल उन्हें सिस्टम में परिभाषित करने पर विचार करें ।eb.Script.Serialization ... एक अन्य ट्रिक एक नेमस्पेस का उपयोग नहीं करने के लिए है, तो आपको उपयोग की आवश्यकता नहीं है सभी पर बयान) और आप उन्हें इस तरह से उपभोग कर सकते हैं:

var serializer = new JavaScriptSerializer();
var value = serializer.DeserializeDynamic("{ 'Name': 'Jon Smith', 'Address': { 'City': 'New York', 'State': 'NY' }, 'Age': 42 }");

var name = (string)value.Name; // Jon Smith
var age = (int)value.Age;      // 42

var address = value.Address;
var city = (string)address.City;   // New York
var state = (string)address.State; // NY

6

आप उपयोग कर सकते हैं using Newtonsoft.Json

var jRoot = 
 JsonConvert.DeserializeObject<dynamic>(Encoding.UTF8.GetString(resolvedEvent.Event.Data));

resolvedEvent.Event.Data कोर इवेंट को कॉल करने से मेरी प्रतिक्रिया मिल रही है।


6

मैं JSON ऑब्जेक्ट का प्रतिनिधित्व करने वाले वर्ग को प्राप्त करने के लिए http://json2csharp.com/ का उपयोग करता हूं ।

इनपुट:

{
   "name":"John",
   "age":31,
   "city":"New York",
   "Childs":[
      {
         "name":"Jim",
         "age":11
      },
      {
         "name":"Tim",
         "age":9
      }
   ]
}

आउटपुट:

public class Child
{
    public string name { get; set; }
    public int age { get; set; }
}

public class Person
{
    public string name { get; set; }
    public int age { get; set; }
    public string city { get; set; }
    public List<Child> Childs { get; set; }
}

उसके बाद मैं Newtonsoft.Json का उपयोग वर्ग भरने के लिए करता हूं :

using Newtonsoft.Json;

namespace GitRepositoryCreator.Common
{
    class JObjects
    {
        public static string Get(object p_object)
        {
            return JsonConvert.SerializeObject(p_object);
        }
        internal static T Get<T>(string p_object)
        {
            return JsonConvert.DeserializeObject<T>(p_object);
        }
    }
}

आप इसे इस तरह कह सकते हैं:

Person jsonClass = JObjects.Get<Person>(stringJson);

string stringJson = JObjects.Get(jsonClass);

पुनश्च:

यदि आपका JSON चर नाम वैध C # नाम नहीं है (नाम से शुरू होता है $) तो आप इसे इस तरह से ठीक कर सकते हैं:

public class Exception
{
   [JsonProperty(PropertyName = "$id")]
   public string id { get; set; }
   public object innerException { get; set; }
   public string message { get; set; }
   public string typeName { get; set; }
   public string typeKey { get; set; }
   public int errorCode { get; set; }
   public int eventId { get; set; }
}

5

उसके लिए मैं JSON.NET का उपयोग JSON स्ट्रीम के निम्न-स्तरीय पार्सिंग को करने के लिए करूँगा और फिर ExpandoObjectकक्षा के उदाहरणों से ऑब्जेक्ट पदानुक्रम का निर्माण करूँगा ।


5

मैं अपने कोड में इस तरह का उपयोग कर रहा हूं और यह ठीक काम कर रहा है

using System.Web.Script.Serialization;
JavaScriptSerializer oJS = new JavaScriptSerializer();
RootObject oRootObject = new RootObject();
oRootObject = oJS.Deserialize<RootObject>(Your JSon String);

1
लेकिन यह वह नहीं है जिसके बारे में सवाल पूछ रहा है। जब आपको हर जॉगन स्ट्रिंग के लिए टाइप करना होता है और डायनामिक टाइप के साथ काम करना होता है, तो अलग होता है।
इलुमिनाती

5

कोडप्रोजेक्ट पर मेरे द्वारा लिखे गए लेख को देखें, जो इस प्रश्न का सटीक उत्तर देता है:

JSON.NET के साथ गतिशील प्रकार

यह सब यहाँ फिर से पोस्ट करने के लिए बहुत ज्यादा है, और यहां तक ​​कि कम बिंदु के बाद से उस लेख को कुंजी / आवश्यक स्रोत फ़ाइल के साथ एक लगाव है।


5

एक अन्य विकल्प "JSON को कक्षाओं के रूप में पेस्ट करें" ताकि इसे त्वरित और आसान बनाया जा सके।

  1. बस अपने पूरे JSON की प्रतिलिपि बनाएँ
  2. विजुअल स्टूडियो में: संपादित करेंवर्गों के रूप में पेस्ट स्पेशलJSON पर क्लिक करें

यहाँ एक बेहतर व्याख्या है n piccas ... ASP.NET और वेब टूल्स 2012.2 RC में 'पेस्ट जोंस अस क्लासेस'


इसने मुझे बहुत समय बचाया! सबसे अच्छा जवाब के रूप में चुना जाना चाहिए!
jsiot

4

JSON.NET में Deserializing JObjectक्लास का उपयोग करके गतिशील हो सकता है , जो उस लाइब्रेरी में शामिल है। मेरा JSON स्ट्रिंग इन वर्गों का प्रतिनिधित्व करता है:

public class Foo {
   public int Age {get;set;}
   public Bar Bar {get;set;}
}

public class Bar {
   public DateTime BDay {get;set;}
}

अब हम उपरोक्त वर्गों को संदर्भित किए बिना स्ट्रिंग का वर्णन करते हैं:

var dyn = JsonConvert.DeserializeObject<JObject>(jsonAsFooString);

JProperty propAge = dyn.Properties().FirstOrDefault(i=>i.Name == "Age");
if(propAge != null) {
    int age = int.Parse(propAge.Value.ToString());
    Console.WriteLine("age=" + age);
}

//or as a one-liner:
int myage = int.Parse(dyn.Properties().First(i=>i.Name == "Age").Value.ToString());

या यदि आप गहराई तक जाना चाहते हैं:

var propBar = dyn.Properties().FirstOrDefault(i=>i.Name == "Bar");
if(propBar != null) {
    JObject o = (JObject)propBar.First();
    var propBDay = o.Properties().FirstOrDefault (i => i.Name=="BDay");
    if(propBDay != null) {
        DateTime bday = DateTime.Parse(propBDay.Value.ToString());
        Console.WriteLine("birthday=" + bday.ToString("MM/dd/yyyy"));
    }
}

//or as a one-liner:
DateTime mybday = DateTime.Parse(((JObject)dyn.Properties().First(i=>i.Name == "Bar").First()).Properties().First(i=>i.Name == "BDay").Value.ToString());

एक पूर्ण उदाहरण के लिए पोस्ट देखें ।


यह दृष्टिकोण jSON दस्तावेज़ को "ट्रैवर्स" करने की अनुमति देता है, ताकि आप ऐसी स्थिति का प्रबंधन कर सकें जहां JSON संरचना अज्ञात या चर है (उदाहरण के लिए, कई API त्रुटि होने पर पूरी तरह से अलग JSON दस्तावेज़ देता है)। ऐसे अन्य पुस्तकालय हैं जो न्यूटंसॉफ्ट के अलावा ऐसा करने की अनुमति देते हैं। JSON (उर्फ JSON.NET)?
एलेक्स 75

4

आप जिस ऑब्जेक्ट को डायनामिकजेनऑब्जेक्ट चाहते हैं, वह ASP.NET वेब पेज पैकेज से System.Web.Helpers.dll में शामिल है, जो वेबमैट्रिक्स का हिस्सा है।


4

C # के लिए एक हल्का JSON लाइब्रेरी है जिसे SimpleJson कहा जाता है ।

यह .NET 3.5+, सिल्वरलाइट और विंडोज फोन 7 को सपोर्ट करता है।

यह .NET 4.0 के लिए गतिशील का समर्थन करता है

इसे NuGet पैकेज के रूप में भी स्थापित किया जा सकता है

Install-Package SimpleJson

4

जावास्क्रिप्ट के साथ डेटासेट (C #) का उपयोग करें। डेटासेट इनपुट के साथ JSON स्ट्रीम बनाने के लिए एक सरल कार्य। JSON सामग्री बनाएं जैसे (मल्टी टेबल डेटासेट):

[[{a:1,b:2,c:3},{a:3,b:5,c:6}],[{a:23,b:45,c:35},{a:58,b:59,c:45}]]

बस ग्राहक पक्ष, eval का उपयोग करें। उदाहरण के लिए,

var d = eval('[[{a:1,b:2,c:3},{a:3,b:5,c:6}],[{a:23,b:45,c:35},{a:58,b:59,c:45}]]')

फिर उपयोग करें:

d[0][0].a // out 1 from table 0 row 0

d[1][1].b // out 59 from table 1 row 1

// Created by Behnam Mohammadi And Saeed Ahmadian
public string jsonMini(DataSet ds)
{
    int t = 0, r = 0, c = 0;
    string stream = "[";

    for (t = 0; t < ds.Tables.Count; t++)
    {
        stream += "[";
        for (r = 0; r < ds.Tables[t].Rows.Count; r++)
        {
            stream += "{";
            for (c = 0; c < ds.Tables[t].Columns.Count; c++)
            {
                stream += ds.Tables[t].Columns[c].ToString() + ":'" +
                          ds.Tables[t].Rows[r][c].ToString() + "',";
            }
            if (c>0)
                stream = stream.Substring(0, stream.Length - 1);
            stream += "},";
        }
        if (r>0)
            stream = stream.Substring(0, stream.Length - 1);
        stream += "],";
    }
    if (t>0)
        stream = stream.Substring(0, stream.Length - 1);
    stream += "];";
    return stream;
}

3

एक विस्तारक विषय प्राप्त करने के लिए:

using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

Container container = JsonConvert.Deserialize<Container>(jsonAsString, new ExpandoObjectConverter());

3

इसे इस्तेमाल करे:

  var units = new { Name = "Phone", Color= "White" };
    var jsonResponse = JsonConvert.DeserializeAnonymousType(json, units);

3

गतिशील और जावास्क्रिप्ट से आसान JSON सामग्री को पार्स करने के लिए कैसे

कृपया System.Web.Extensions का संदर्भ जोड़ें और using System.Web.Script.Serialization;शीर्ष पर इस नाम स्थान को जोड़ें :

public static void EasyJson()
{
    var jsonText = @"{
        ""some_number"": 108.541,
        ""date_time"": ""2011-04-13T15:34:09Z"",
        ""serial_number"": ""SN1234""
    }";

    var jss = new JavaScriptSerializer();
    var dict = jss.Deserialize<dynamic>(jsonText);

    Console.WriteLine(dict["some_number"]);
    Console.ReadLine();
}

डायनेमिक और जावास्क्रिप्ट सर्वर के साथ नेस्टेड और कॉम्प्लेक्स जोंस को पार्स कैसे करें

कृपया System.Web.Extensions का संदर्भ जोड़ें और using System.Web.Script.Serialization;शीर्ष पर इस नाम स्थान को जोड़ें :

public static void ComplexJson()
{
    var jsonText = @"{
        ""some_number"": 108.541,
        ""date_time"": ""2011-04-13T15:34:09Z"",
        ""serial_number"": ""SN1234"",
        ""more_data"": {
            ""field1"": 1.0,
            ""field2"": ""hello""
        }
    }";

    var jss = new JavaScriptSerializer();
    var dict = jss.Deserialize<dynamic>(jsonText);

    Console.WriteLine(dict["some_number"]);
    Console.WriteLine(dict["more_data"]["field2"]);
    Console.ReadLine();
}

1

Cinchoo ETL के साथ - JSON को डायनामिक ऑब्जेक्ट में पार्स करने के लिए एक ओपन सोर्स लाइब्रेरी उपलब्ध है:

string json = @"{
    ""key1"": [
        {
            ""action"": ""open"",
            ""timestamp"": ""2018-09-05 20:46:00"",
            ""url"": null,
            ""ip"": ""66.102.6.98""
        }
    ]
}";
using (var p = ChoJSONReader.LoadText(json)
    .WithJSONPath("$.*")
    )
{
    foreach (var rec in p)
    {
        Console.WriteLine("Action: " + rec.action);
        Console.WriteLine("Timestamp: " + rec.timestamp);
        Console.WriteLine("URL: " + rec.url);
        Console.WriteLine("IP address: " + rec.ip);
    }
}

आउटपुट:

Action: open
Timestamp: 2018-09-05 20:46:00
URL: http://www.google.com
IP address: 66.102.6.98

अस्वीकरण: मैं इस पुस्तकालय का लेखक हूं।


0

इस तरह से कोशिश करो!

JSON उदाहरण:

  [{
            "id": 140,
            "group": 1,
            "text": "xxx",
            "creation_date": 123456,
            "created_by": "xxx@gmail.co",
            "tags": ["xxxxx"]
        }, {
            "id": 141,
            "group": 1,
            "text": "xxxx",
            "creation_date": 123456,
            "created_by": "xxx@gmail.com",
            "tags": ["xxxxx"]
        }]

C # कोड:

        var jsonString = (File.ReadAllText(Path.Combine(Directory.GetCurrentDirectory(),"delete_result.json")));
        var objects = JsonConvert.DeserializeObject<dynamic>(jsonString);
        foreach(var o in objects)
        {
            Console.WriteLine($"{o.id.ToString()}");
        }
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.