c# - जेएसओएन को सी#गतिशील वस्तु में deserialize?




.net json (15)

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

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

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

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


ExpandoObject प्राप्त करने के लिए:

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

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

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

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

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


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

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

फिर आपको उस नामस्थान के लिए एक उपयोग कथन रखने की आवश्यकता है जिसमें आपने एक्सटेंशन को परिभाषित किया है (केवल उन्हें System.Web.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

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

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

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

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

यहां एक बेहतर स्पष्टीकरण n piccas है ... https://blogs.msdn.microsoft.com/webdev/2012/12/18/paste-json-as-classes-in-asp-net-and-web-tools-2012-2-rc/


कोडप्रोजेक्ट पर लिखे आलेख को देखें, जो कि प्रश्न का उत्तर देता है:

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

अब हम उपर्युक्त वर्गों को संदर्भित किए बिना स्ट्रिंग को deserialize:

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

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


डेटासेट (सी #) का उपयोग करें डेटासेट इनपुट के साथ जेसन स्ट्रीम बनाने के लिए जावास्क्रिप्ट सरल फ़ंक्शन के साथ जेसन जैसे (बहु तालिका डेटासेट) [[{a: 1, b: 2, c: 3}, {a: 3, b: 5, c : 6}], [{a: 23, ख: 45, सी: 35}, {एक: 58, ख: 59, सी: 45}]]

उदाहरण के लिए क्लाइंट साइड का उपयोग केवल eval

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

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

डी [0] [0] .a // आउट 1 तालिका 0 पंक्ति 0 से

डी [1] [1] .b // तालिका 1 पंक्ति 1 से 59

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

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

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

मैंने डायनामिक जेसन कनवर्टर का एक नया संस्करण बनाया जो एक्सपोन्ड ऑब्जेक्ट्स का उपयोग करता है। मैंने विस्तारित ऑब्जेक्ट्स का उपयोग किया क्योंकि मैं जेसननेट का उपयोग कर गतिशील बैक को जेसन में सीरियलाइज़ करना चाहता था।

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

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


सी # के लिए लाइटवेट जेसन लाइब्रेरी है जिसे सिंपलजेसन कहा जाता है जो http://simplejson.codeplex.com पर पाया जा सकता है https://github.com/facebook-csharp-sdk/simple-json

यह नेट 3.5+, चांदी की रोशनी और विंडोज फोन 7 का समर्थन करता है।

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

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

Install-Package SimpleJson

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 भी 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;

प्रलेखन: जेएसओएन गतिशील के साथ पूछताछ


यदि आप System.Web.Helpers असेंबली पर निर्भरता प्राप्त करने में प्रसन्न हैं, तो आप Json कक्षा का उपयोग कर सकते हैं:

dynamic data = Json.Decode(json);

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

यहां एक वैकल्पिक deserialisation दृष्टिकोण का सुझाव दिया गया here । मैंने एक कोड को ठीक करने के लिए कोड को थोड़ा संशोधित किया और मेरी कोडिंग शैली को सूट किया। आपको बस इतना ही चाहिए कि यह कोड और आपके प्रोजेक्ट से 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)




dynamic