दिलचस्प पोस्ट
क्या सी के लिए कोई दुभाषिया है? मानचित्र के keySet () और entrySet () के लिए प्रदर्शन संबंधी विचार एक्सरस को प्रत्येक पंक्ति की इनपुट के लिए एक बार कमांड करें एनिमेटिंग यूआईएलएबल फ़ॉन्ट आकार बदलें sendAsynchronousRequest का उपयोग कैसे करें: कतार: पूरा होन्डलर: कैसे एक tensorflow चर को मान असाइन करने के लिए? मैं प्रोग्रामैटिक रूप से यह निर्धारित कैसे कर सकता हूं कि मेरा ऐप iPhone सिम्युलेटर में चल रहा है या नहीं? पार्सल योग्य / कहां है जब वर्णन कंटेंट () का उपयोग किया जाता है? jQuery सीएसएस – <style> -tag में लिखें समस्याओं का संकलन: crt1.o नहीं मिल सकता जावा जेनेरिक – टाइप एराज़र – कब और क्या होता है क्या प्रवेश में रिकर्सिव क्वेरी बनाना संभव है? जावा में ऑपरेटर ओवरलोडिंग एक किंवदंती में रंग और आकार के लिए किंवदंतियों का मिश्रण Android TextView में पाठ कर्निंग को कैसे समायोजित करें?

मैं एक साधारण शब्दकोश में स्ट्रिंग> asp.net में json को कैसे हटा सकता हूं?

मेरे पास एक साधारण कुंजी / मूल्य सूची है जो कि पोस्ट करने के बाद एएसपी.नेट पर वापस भेजी जा रही है। उदाहरण:

{ "key1": "value1", "key2": "value2"} 

मैं दृढ़तापूर्वक टाइप किए गए विषयों के बारे में नहीं बता रहा हूं। नेट ऑब्जेक्ट

मुझे केवल एक सादे पुराने शब्द (स्ट्रिंग, स्ट्रिंग) की आवश्यकता है , या कुछ समतुल्य (हैश तालिका, शब्दकोश (स्ट्रिंग, ऑब्जेक्ट), पुराने स्कूल स्ट्रिंग डिज़ाइन – नरक, 2-डी स्ट्रिंग्स की स्ट्रिंग मेरे लिए काम करेगी

मैं एएसपी। नेट 3.5 में उपलब्ध कुछ भी इस्तेमाल कर सकता हूं, साथ ही लोकप्रिय जेसन। नेट (जो मैं ग्राहक के लिए सीरियलाइजेशन के लिए पहले से उपयोग कर रहा हूं)

स्पष्ट रूप से इन जेएसओएन पुस्तकालयों में से न तो बॉक्स के बाहर माथे-चप्पल स्पष्ट क्षमता है- वे मजबूत अनुबंधों के माध्यम से प्रतिबिंब-आधारित deserialization पर पूरी तरह ध्यान केंद्रित कर रहे हैं।

कोई विचार?

सीमाएं:

  1. मैं अपने खुद के JSON पार्सर को लागू नहीं करना चाहता
  2. अभी तक एएसपी.नेट 4.0 का उपयोग नहीं किया जा सकता है
  3. JSON के लिए पुराने, बहिष्कृत ASP.NET वर्ग से दूर रहना पसंद करेंगे

Solutions Collecting From Web of "मैं एक साधारण शब्दकोश में स्ट्रिंग> asp.net में json को कैसे हटा सकता हूं?"

Json.NET यह करता है …

 string json = @"{""key1"":""value1"",""key2"":""value2""}"; var values = JsonConvert.DeserializeObject<Dictionary<string, string>>(json); 

अधिक उदाहरण: जेसन.नेट के साथ संग्रह को सीरियल करना

मुझे पता चला है कि .NET ने एक JSON स्ट्रिंग को एक Dictionary<String, Object> माध्यम से डाली है। System.Web.Script.Serialization.JavaScriptSerializer प्रकार में 3.5 System.Web.ExtensionsSystem.Web.Extensions विधानसभा विधि DeserializeObject(String) उपयोग करें

मैं सामग्री प्रकार 'एप्लिकेशन / जेएसन' की एक एजेक्स पोस्ट (jquery के माध्यम से) एक स्थैतिक .net पेज विधि में करने पर ठोकर खाई और देखा कि जिस पद्धति (जिस प्रकार के Object का एक पैरामीटर था) जादुई रूप से इस शब्दकोश को प्राप्त हुआ।

इंटरनेट पर खोज करने और इस पोस्ट पर ठोकर रखने वालों के लिए, मैंने एक ब्लॉग पोस्ट लिखा था कि जावास्क्रिप्ट एसईराइलाइजर क्लास का उपयोग कैसे किया जाए।

और पढ़ें … http://procbits.com/2011/04/21/quick-json-serializationdeserialization-in-c/

यहाँ एक उदाहरण है:

 var json = "{\"id\":\"13\", \"value\": true}"; var jss = new JavaScriptSerializer(); var table = jss.Deserialize<dynamic>(json); Console.WriteLine(table["id"]); Console.WriteLine(table["value"]); 

किसी भी बाहरी JSON कार्यान्वयन का उपयोग न करने की कोशिश की ताकि मैं इस तरह deserialised:

 string json = "{\"id\":\"13\", \"value\": true}"; var serializer = new JavaScriptSerializer(); //using System.Web.Script.Serialization; Dictionary<string, string> values = serializer.Deserialize<Dictionary<string, string>>(json); 

मुझे यही समस्या थी इसलिए मैंने यह लिखा था कि मैं स्वयं हूं यह समाधान अन्य उत्तरों से भेदभाव करता है क्योंकि यह कई स्तरों को डिसेरीलाइज़ कर सकता है।

बस json स्ट्रिंग को deserialize में भेज दें। नियोजक फ़ंक्शन यह बिना जोरदार टाइप किए गए Dictionary<string, object> object को वापस करेगा

 private Dictionary<string, object> deserializeToDictionary(string jo) { var values = JsonConvert.DeserializeObject<Dictionary<string, object>>(jo); var values2 = new Dictionary<string, object>(); foreach (KeyValuePair<string, object> d in values) { // if (d.Value.GetType().FullName.Contains("Newtonsoft.Json.Linq.JObject")) if (d.Value is JObject) { values2.Add(d.Key, deserializeToDictionary(d.Value.ToString())); } else { values2.Add(d.Key, d.Value); } } return values2; } 

पूर्व: यह एक फेसबुक JSON प्रतिक्रिया के Dictionary<string, object> ऑब्जेक्ट को वापस करेगा

 private void button1_Click(object sender, EventArgs e) { string responsestring = "{\"id\":\"721055828\",\"name\":\"Dasun Sameera Weerasinghe\",\"first_name\":\"Dasun\",\"middle_name\":\"Sameera\",\"last_name\":\"Weerasinghe\",\"username\":\"dasun\",\"gender\":\"male\",\"locale\":\"en_US\", hometown: {id: \"108388329191258\", name: \"Moratuwa, Sri Lanka\",}}"; Dictionary<string, object> values = deserializeToDictionary(responsestring); } 

नोट: गृहनगर आगे एक Dictionary<string, object> object

यदि आप हल्के, ना-वर्धित-संदर्भों के प्रकार के बाद होते हैं, तो शायद मैंने लिखा लिखे कोड का यह छोटा काम करेगा (हालांकि मैं 100% गारंटी नहीं दे सकता)।

 using System; using System.Collections.Generic; using System.Text; using System.Text.RegularExpressions; public Dictionary<string, object> ParseJSON(string json) { int end; return ParseJSON(json, 0, out end); } private Dictionary<string, object> ParseJSON(string json, int start, out int end) { Dictionary<string, object> dict = new Dictionary<string, object>(); bool escbegin = false; bool escend = false; bool inquotes = false; string key = null; int cend; StringBuilder sb = new StringBuilder(); Dictionary<string, object> child = null; List<object> arraylist = null; Regex regex = new Regex(@"\\u([0-9a-z]{4})", RegexOptions.IgnoreCase); int autoKey = 0; for (int i = start; i < json.Length; i++) { char c = json[i]; if (c == '\\') escbegin = !escbegin; if (!escbegin) { if (c == '"') { inquotes = !inquotes; if (!inquotes && arraylist != null) { arraylist.Add(DecodeString(regex, sb.ToString())); sb.Length = 0; } continue; } if (!inquotes) { switch (c) { case '{': if (i != start) { child = ParseJSON(json, i, out cend); if (arraylist != null) arraylist.Add(child); else { dict.Add(key, child); key = null; } i = cend; } continue; case '}': end = i; if (key != null) { if (arraylist != null) dict.Add(key, arraylist); else dict.Add(key, DecodeString(regex, sb.ToString())); } return dict; case '[': arraylist = new List<object>(); continue; case ']': if (key == null) { key = "array" + autoKey.ToString(); autoKey++; } if (arraylist != null && sb.Length > 0) { arraylist.Add(sb.ToString()); sb.Length = 0; } dict.Add(key, arraylist); arraylist = null; key = null; continue; case ',': if (arraylist == null && key != null) { dict.Add(key, DecodeString(regex, sb.ToString())); key = null; sb.Length = 0; } if (arraylist != null && sb.Length > 0) { arraylist.Add(sb.ToString()); sb.Length = 0; } continue; case ':': key = DecodeString(regex, sb.ToString()); sb.Length = 0; continue; } } } sb.Append(c); if (escend) escbegin = false; if (escbegin) escend = true; else escend = false; } end = json.Length - 1; return dict; //theoretically shouldn't ever get here } private string DecodeString(Regex regex, string str) { return Regex.Unescape(regex.Replace(str, match => char.ConvertFromUtf32(Int32.Parse(match.Groups[1].Value, System.Globalization.NumberStyles.HexNumber)))); } 

[मुझे पता है कि यह ओपी सीमा # 1 का उल्लंघन करता है, लेकिन तकनीकी तौर पर, आपने इसे नहीं लिखा, मैंने किया]

संपादित करें: यह काम करता है, लेकिन Json.NET का उपयोग करते हुए स्वीकृत उत्तर अधिक सरल है। अगर किसी को बीसीएल-केवल कोड की आवश्यकता होती है तो उसे छोड़कर

यह बॉक्स के बाहर .NET ढांचे द्वारा समर्थित नहीं है। एक चमकदार निरीक्षण – हर किसी को नामित संपत्तियों के साथ वस्तुओं में उतारा नहीं होना चाहिए इसलिए मैंने अपना रोलिंग समाप्त कर दिया:

 <Serializable()> Public Class StringStringDictionary Implements ISerializable Public dict As System.Collections.Generic.Dictionary(Of String, String) Public Sub New() dict = New System.Collections.Generic.Dictionary(Of String, String) End Sub Protected Sub New(info As SerializationInfo, _ context As StreamingContext) dict = New System.Collections.Generic.Dictionary(Of String, String) For Each entry As SerializationEntry In info dict.Add(entry.Name, DirectCast(entry.Value, String)) Next End Sub Public Sub GetObjectData(info As SerializationInfo, context As StreamingContext) Implements ISerializable.GetObjectData For Each key As String in dict.Keys info.AddValue(key, dict.Item(key)) Next End Sub End Class 

इसके साथ बुलाया गया:

 string MyJsonString = "{ \"key1\": \"value1\", \"key2\": \"value2\"}"; System.Runtime.Serialization.Json.DataContractJsonSerializer dcjs = new System.Runtime.Serialization.Json.DataContractJsonSerializer( typeof(StringStringDictionary)); System.IO.MemoryStream ms = new System.IO.MemoryStream(Encoding.UTF8.GetBytes(MyJsonString)); StringStringDictionary myfields = (StringStringDictionary)dcjs.ReadObject(ms); Response.Write("Value of key2: " + myfields.dict["key2"]); 

सी # और VB.NET के मिश्रण के लिए क्षमा करें …

मुझे बस नेस्टेड डिक्शनरी को पार्स करने की जरूरत है, जैसे कि

 { "x": { "a": 1, "b": 2, "c": 3 } } 

जहां JsonConvert.DeserializeObject मदद नहीं करता है मुझे निम्नलिखित दृष्टिकोण मिला:

 var dict = JObject.Parse(json).SelectToken("x").ToObject<Dictionary<string, int>>(); 

SelectToken आपको इच्छित फ़ील्ड में खोदने देता है। आप JSON ऑब्जेक्ट में आगे नीचे कदम के लिए "xyz" जैसे पथ को निर्दिष्ट भी कर सकते हैं।

मैंने दूसरे उत्तर में JSON में शून्य मानों के लिए एक चेक जोड़ा

मुझे यही समस्या थी इसलिए मैंने यह लिखा था कि मैं स्वयं हूं यह समाधान अन्य उत्तरों से भेदभाव करता है क्योंकि यह कई स्तरों को डिसेरीलाइज़ कर सकता है।

बस json स्ट्रिंग को deserialize में भेज दें। नियोजक फ़ंक्शन यह बिना जोरदार टाइप किए गए Dictionary<string, object> object को वापस करेगा

 private Dictionary<string, object> deserializeToDictionary(string jo) { var values = JsonConvert.DeserializeObject<Dictionary<string, object>>(jo); var values2 = new Dictionary<string, object>(); foreach (KeyValuePair<string, object> d in values) { if (d.Value != null && d.Value.GetType().FullName.Contains("Newtonsoft.Json.Linq.JObject")) { values2.Add(d.Key, deserializeToDictionary(d.Value.ToString())); } else { values2.Add(d.Key, d.Value); } } return values2; } 

पूर्व: यह एक फेसबुक JSON प्रतिक्रिया के Dictionary<string, object> ऑब्जेक्ट को वापस करेगा

 private void button1_Click(object sender, EventArgs e) { string responsestring = "{\"id\":\"721055828\",\"name\":\"Dasun Sameera Weerasinghe\",\"first_name\":\"Dasun\",\"middle_name\":\"Sameera\",\"last_name\":\"Weerasinghe\",\"username\":\"dasun\",\"gender\":\"male\",\"locale\":\"en_US\", hometown: {id: \"108388329191258\", name: \"Moratuwa, Sri Lanka\",}}"; Dictionary<string, object> values = deserializeToDictionary(responsestring); } 

नोट: गृहनगर आगे एक Dictionary<string, object> वस्तु में deserialize

मैंने jsnake04 और दसन द्वारा प्रस्तुत कोड पर इसके बारे में जोड़ा है। मैंने JArray इंस्टेंस से ऑब्जेक्ट की सूची बनाने के लिए कोड जोड़ा है। यह दो-तरफा पुनरावर्ती है लेकिन जैसा कि यह एक निश्चित, परिमित ट्री मॉडल पर काम कर रहा है, स्टैक अतिप्रवाह का कोई खतरा नहीं है, जब तक डेटा बड़े नहीं होता है

 /// <summary> /// Deserialize the given JSON string data (<paramref name="data"/>) into a /// dictionary. /// </summary> /// <param name="data">JSON string.</param> /// <returns>Deserialized dictionary.</returns> private IDictionary<string, object> DeserializeData(string data) { var values = JsonConvert.DeserializeObject<Dictionary<string, object>>(data); return DeserializeData(values); } /// <summary> /// Deserialize the given JSON object (<paramref name="data"/>) into a dictionary. /// </summary> /// <param name="data">JSON object.</param> /// <returns>Deserialized dictionary.</returns> private IDictionary<string, object> DeserializeData(JObject data) { var dict = data.ToObject<Dictionary<String, Object>>(); return DeserializeData(dict); } /// <summary> /// Deserialize any elements of the given data dictionary (<paramref name="data"/>) /// that are JSON object or JSON arrays into dictionaries or lists respectively. /// </summary> /// <param name="data">Data dictionary.</param> /// <returns>Deserialized dictionary.</returns> private IDictionary<string, object> DeserializeData(IDictionary<string, object> data) { foreach (var key in data.Keys.ToArray()) { var value = data[key]; if (value is JObject) data[key] = DeserializeData(value as JObject); if (value is JArray) data[key] = DeserializeData(value as JArray); } return data; } /// <summary> /// Deserialize the given JSON array (<paramref name="data"/>) into a list. /// </summary> /// <param name="data">Data dictionary.</param> /// <returns>Deserialized list.</returns> private IList<Object> DeserializeData(JArray data) { var list = data.ToObject<List<Object>>(); for (int i = 0; i < list.Count; i++) { var value = list[i]; if (value is JObject) list[i] = DeserializeData(value as JObject); if (value is JArray) list[i] = DeserializeData(value as JArray); } return list; } 

मार्क रेंडल ने इसे एक टिप्पणी के रूप में पोस्ट किया, मैं इसे एक उत्तर के रूप में पोस्ट करना चाहता था क्योंकि यह एकमात्र हल है जिसने अभी तक सफलता वापस लौटाया है और Google reCaptcha प्रतिक्रिया से त्रुटि कोड JSON परिणाम

 string jsonReponseString= wClient.DownloadString(requestUrl); IDictionary<string, object> dict = new JavaScriptSerializer().DeserializeObject(jsonReponseString) as IDictionary<string, object>; 

धन्यवाद फिर से, मार्क!

ऐसा लगता है कि इन सभी उत्तर यहां दिए गए हैं, बस मान लीजिए कि आप उस छोटी सी स्ट्रिंग को एक बड़ी वस्तु से बाहर निकाल सकते हैं … लोगों को सिर्फ एक ऐसी वस्तु के साथ एक बड़ी वस्तु को नाराज करना, मानचित्रण के अंदर कहीं और, जो सिस्टम का उपयोग कर रहे हैं System.Runtime.Serialization.Json जेसन System.Runtime.Serialization.Json कंट्रैक्ट्रिक सिस्टम, यहां एक समाधान है:

Gis.stackexchange.com पर एक उत्तर इस दिलचस्प लिंक था । मुझे archive.org के साथ इसे पुनर्प्राप्त करना पड़ा, लेकिन यह एकदम सही समाधान प्रदान करता है: एक कस्टम IDataContractSurrogate वर्ग जिसमें आप बिल्कुल अपने स्वयं के प्रकारों को लागू करते हैं मैं इसे आसानी से विस्तारित करने में सक्षम था

मैंने इसमें कुछ परिवर्तन किए, हालांकि। चूंकि मूल स्रोत अब उपलब्ध नहीं है, इसलिए मैं यहाँ पूरी कक्षा पोस्ट करूँगा:

 using System; using System.CodeDom; using System.Collections.Generic; using System.Collections.ObjectModel; using System.IO; using System.Linq; using System.Reflection; using System.Runtime.Serialization; using System.Runtime.Serialization.Json; using System.Text; namespace JsonTools { /// <summary> /// Allows using Dictionary&lt;String,String&gt; and Dictionary&lt;String,Boolean&gt; types, and any others you'd like to add. /// Source: https://web.archive.org/web/20100317222656/my6solutions.com/post/2009/06/30/DataContractSerializer-DataContractJsonSerializer-JavaScriptSerializer-XmlSerializer-for-serialization.aspx /// </summary> public class JsonSurrogate : IDataContractSurrogate { /// <summary> /// Deserialize an object with added support for the types defined in this class. /// </summary> /// <typeparam name="T">Contract class</typeparam> /// <param name="json">JSON String</param> /// <param name="encoding">Text encoding</param> /// <returns>The deserialized object of type T</returns> public static T Deserialize<T>(String json, Encoding encoding) { if (encoding == null) encoding = new UTF8Encoding(false); DataContractJsonSerializer deserializer = new DataContractJsonSerializer( typeof(T), new Type[0], int.MaxValue, true, new JsonSurrogate(), false); using (MemoryStream stream = new MemoryStream(encoding.GetBytes(json))) { T result = (T)deserializer.ReadObject(stream); return result; } } // make sure all values in this are classes implementing JsonSurrogateObject. private static Dictionary<Type, Type> KnownTypes = new Dictionary<Type, Type>() { {typeof(Dictionary<String, String>), typeof(SSDictionary)}, {typeof(Dictionary<String, Boolean>), typeof(SBDictionary)} }; #region Implemented surrogate dictionary classes [Serializable] public class SSDictionary : SurrogateDictionary<String> { public SSDictionary() : base() {} protected SSDictionary (SerializationInfo info, StreamingContext context) : base(info, context) {} } [Serializable] public class SBDictionary : SurrogateDictionary<Boolean> { public SBDictionary() : base() {} protected SBDictionary (SerializationInfo info, StreamingContext context) : base(info, context) {} } #endregion /// <summary>Small interface to easily extract the final value from the object.</summary> public interface JsonSurrogateObject { Object DeserializedObject { get; } } /// <summary> /// Class for deserializing any simple dictionary types with a string as key. /// </summary> /// <typeparam name="T">Any simple type that will be deserialized correctly.</typeparam> [Serializable] public abstract class SurrogateDictionary<T> : ISerializable, JsonSurrogateObject { public Object DeserializedObject { get { return dict; } } private Dictionary<String, T> dict; public SurrogateDictionary() { dict = new Dictionary<String, T>(); } // deserialize protected SurrogateDictionary(SerializationInfo info, StreamingContext context) { dict = new Dictionary<String, T>(); foreach (SerializationEntry entry in info) { // This cast will only work for base types, of course. dict.Add(entry.Name, (T)entry.Value); } } // serialize public void GetObjectData(SerializationInfo info, StreamingContext context) { foreach (String key in dict.Keys) { info.AddValue(key, dict[key]); } } } /// <summary> /// Uses the KnownTypes dictionary to get the surrogate classes. /// </summary> /// <param name="type"></param> /// <returns></returns> public Type GetDataContractType(Type type) { Type returnType; if (KnownTypes.TryGetValue(type, out returnType)) { return returnType; } return type; } public object GetObjectToSerialize(object obj, Type targetType) { throw new NotImplementedException(); } /// <summary> /// Gets the object out of the surrogate datacontract object. This function is the reason all surrogate objects need to implement the JsonSurrogateObject class. /// </summary> /// <param name="obj">Result of the deserialization</param> /// <param name="targetType">Expected target type of the deserialization</param> /// <returns></returns> public object GetDeserializedObject(object obj, Type targetType) { if (obj is JsonSurrogateObject) { return ((JsonSurrogateObject)obj).DeserializedObject; } return obj; } public Type GetReferencedTypeOnImport(string typeName, string typeNamespace, object customData) { return null; } #region not implemented public object GetCustomDataToExport(MemberInfo memberInfo, Type dataContractType) { throw new NotImplementedException(); } public object GetCustomDataToExport(Type clrType, Type dataContractType) { throw new NotImplementedException(); } public void GetKnownCustomDataTypes(Collection<Type> customDataTypes) { throw new NotImplementedException(); } public CodeTypeDeclaration ProcessImportedType(CodeTypeDeclaration typeDeclaration, CodeCompileUnit compileUnit) { throw new NotImplementedException(); } #endregion } } 

क्लास में नए समर्थित प्रकार जोड़ने के लिए, आपको अपने क्लास को जोड़ने की जरूरत है, इसे सही कन्स्ट्रक्टर और फ़ंक्शन प्रदान करें (उदाहरण के लिए SurrogateDictionary JsonSurrogateObject को JsonSurrogateObject ), यह सुनिश्चित करें कि यह JsonSurrogateObject को JsonSurrogateObject , और इसकी प्रकार मैपिंग KnownTypes शब्दकोश में जोड़ें शामिल किए गए सरोगेट Dictionary<String,T> किसी भी Dictionary<String,T> प्रकार के आधार के रूप में सेवा कर सकते हैं जहां टी किसी प्रकार का है जो सही ढंग से deserialize करता है

इसे कॉल करना वास्तव में सरल है:

 MyObjtype newObj = JsonSurrogate.Deserialize<MyObjtype>(jsonStr, encoding); 

ध्यान दें कि किसी कारण के लिए यह चीज कुंजी स्ट्रिंग्स का उपयोग करने में परेशानी होती है जिसमें रिक्त स्थान शामिल होते हैं; वे केवल अंतिम सूची में मौजूद नहीं थे। हो सकता है कि यह सिर्फ जेसन चश्मा के खिलाफ हो और मैं जिस एपीआई को बुला रहा था वह खराब लागू किया गया था, आपको याद रखना; मुझे नही पता। वैसे भी, मैंने इसे regex द्वारा हल किया- उन्हें कच्चे जेएसन डेटा में अंडरस्कोर के साथ बदल दिया और deserialization के बाद शब्दकोश को ठीक करना।

मैंने इसे बस RestSharp में लागू किया है यह पोस्ट मेरे लिए सहायक थी

लिंक के कोड के अलावा, यहां मेरा कोड है I जब मैं ऐसा कुछ करता हूं तो मुझे अब परिणाम का एक Dictionary मिलता है:

 var jsonClient = new RestClient(url.Host); jsonClient.AddHandler("application/json", new DynamicJsonDeserializer()); var jsonRequest = new RestRequest(url.Query, Method.GET); Dictionary<string, dynamic> response = jsonClient.Execute<JObject>(jsonRequest).Data.ToObject<Dictionary<string, dynamic>>(); 

जिस प्रकार की JSON की आप उम्मीद कर रहे हैं, उसके बारे में सावधान रहें – मेरे मामले में, मैं एक ही ऑब्जेक्ट कई गुणों के साथ पुनर्प्राप्त कर रहा था। संलग्न लिंक में लेखक एक सूची पुनः प्राप्त कर रहा था।

मेरा दृष्टिकोण सीधे IDictionary को बेकार करता है, बिना एज़ेजेक्ट या एक्सपेंड ऑब्जेक्ट के बीच। कोड कनवर्टर का उपयोग करता है, जो मूलतः JSON.NET स्रोत कोड में पाया गया ExpandoObjectConverter वर्ग से कॉपी किया गया है, लेकिन ExpandoObject के बजाय IDictionary का उपयोग कर रहा है।

उपयोग:

 var settings = new JsonSerializerSettings() { Converters = { new DictionaryConverter() }, }; var result = JsonConvert.DeserializeObject<IDictionary<string, object>>(json, settings); 

कोड:

 // based on ExpandoObjectConverter, but using arrays instead of IList, to behave similar to System.Web.Script.Serialization.JavaScriptSerializer public class DictionaryConverter : JsonConverter { public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { } public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { return ReadValue(reader); } public override bool CanConvert(Type objectType) { return (objectType == typeof(IDictionary<string, object>)); } public override bool CanWrite { get { return false; } } private object ReadValue(JsonReader reader) { while (reader.TokenType == JsonToken.Comment) { if (!reader.Read()) throw JsonSerializationExceptionCreate(reader, "Unexpected end when reading IDictionary<string, object>."); } switch (reader.TokenType) { case JsonToken.StartObject: return ReadObject(reader); case JsonToken.StartArray: return ReadList(reader); default: if (IsPrimitiveToken(reader.TokenType)) return reader.Value; throw JsonSerializationExceptionCreate(reader, string.Format(CultureInfo.InvariantCulture, "Unexpected token when converting IDictionary<string, object>: {0}", reader.TokenType)); } } private object ReadList(JsonReader reader) { List<object> list = new List<object>(); while (reader.Read()) { switch (reader.TokenType) { case JsonToken.Comment: break; default: object v = ReadValue(reader); list.Add(v); break; case JsonToken.EndArray: return list; } } throw JsonSerializationExceptionCreate(reader, "Unexpected end when reading IDictionary<string, object>."); } private object ReadObject(JsonReader reader) { IDictionary<string, object> dictionary = new Dictionary<string, object>(); while (reader.Read()) { switch (reader.TokenType) { case JsonToken.PropertyName: string propertyName = reader.Value.ToString(); if (!reader.Read()) throw JsonSerializationExceptionCreate(reader, "Unexpected end when reading IDictionary<string, object>."); object v = ReadValue(reader); dictionary[propertyName] = v; break; case JsonToken.Comment: break; case JsonToken.EndObject: return dictionary; } } throw JsonSerializationExceptionCreate(reader, "Unexpected end when reading IDictionary<string, object>."); } //based on internal Newtonsoft.Json.JsonReader.IsPrimitiveToken internal static bool IsPrimitiveToken(JsonToken token) { switch (token) { 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 true; default: return false; } } // based on internal Newtonsoft.Json.JsonSerializationException.Create private static JsonSerializationException JsonSerializationExceptionCreate(JsonReader reader, string message, Exception ex = null) { return JsonSerializationExceptionCreate(reader as IJsonLineInfo, reader.Path, message, ex); } // based on internal Newtonsoft.Json.JsonSerializationException.Create private static JsonSerializationException JsonSerializationExceptionCreate(IJsonLineInfo lineInfo, string path, string message, Exception ex) { message = JsonPositionFormatMessage(lineInfo, path, message); return new JsonSerializationException(message, ex); } // based on internal Newtonsoft.Json.JsonPosition.FormatMessage internal static string JsonPositionFormatMessage(IJsonLineInfo lineInfo, string path, string message) { if (!message.EndsWith(Environment.NewLine)) { message = message.Trim(); if (!message.EndsWith(".", StringComparison.Ordinal)) message += "."; message += " "; } message += string.Format(CultureInfo.InvariantCulture, "Path '{0}'", path); if (lineInfo != null && lineInfo.HasLineInfo()) message += string.Format(CultureInfo.InvariantCulture, ", line {0}, position {1}", lineInfo.LineNumber, lineInfo.LinePosition); message += "."; return message; } } 

यदि आप डिफ़ॉल्ट मॉडल बाइंडर का उपयोग करना चाहते हैं, तो आप को ऐसा लगता है कि आपको फॉर्म के रूप में संख्यात्मक सूचकांक मूल्यों का उपयोग करना होगा।

इस लेख http://msdn.microsoft.com/en-us/magazine/hh781022.aspx से निम्न अंश देखें:

यद्यपि यह कुछ विषमतापूर्ण है, लेकिन JSON अनुरोधों की एक ही आवश्यकताएँ हैं-वे भी, नाम के बाद के नामकरण वाक्यविन्यास का पालन करना चाहिए। उदाहरण के लिए, पिछले यूनिट पीरिस कलेक्शन के लिए जेसनॉन पेलोड लें। इस डेटा के लिए शुद्ध JSON सरणी सिंटैक्स का प्रतिनिधित्व होगा:

 [ { "Code": "USD", "Amount": 100.00 }, { "Code": "EUR", "Amount": 73.64 } ] 

हालांकि, डिफ़ॉल्ट मान प्रदाताओं और मॉडल बाइंडर्स को डेटा को JSON फॉर्म पोस्ट के रूप में प्रस्तुत करने की आवश्यकता होती है:

 { "UnitPrice[0].Code": "USD", "UnitPrice[0].Amount": 100.00, "UnitPrice[1].Code": "EUR", "UnitPrice[1].Amount": 73.64 } 

जटिल ऑब्जेक्ट संग्रह परिदृश्य शायद सबसे व्यापक रूप से समस्याग्रस्त परिदृश्यों में से एक है, जो डेवलपर्स में चलते हैं क्योंकि सिंटैक्स सभी डेवलपर्स के लिए जरूरी नहीं है। हालांकि, एक बार जब आप जटिल संग्रह पोस्ट करने के लिए अपेक्षाकृत सरल सिंटैक्स सीखते हैं, तो इन परिदृश्यों से निपटना आसान हो जाता है।

मैं System.Runtime.Serialization.Json का उपयोग करने का सुझाव देता हूं जो .NET 4.5 का हिस्सा है।

 [DataContract] public class Foo { [DataMember(Name = "data")] public Dictionary<string,string> Data { get; set; } } 

फिर इसे इस तरह प्रयोग करें:

  var serializer = new DataContractJsonSerializer(typeof(List<Foo>)); var jsonParams = @"{""data"": [{""Key"":""foo"",""Value"":""bar""}] }"; var stream = new MemoryStream(Encoding.UTF8.GetBytes(jsonParams)); var obj = serializer.ReadObject(stream); Console.WriteLine(obj); 

If you don't want or can't add a large third-party library like Json.NET (for example, because you're using Unity3D), I really recommend taking a look at MiniJSON . Short and sweet code, easy to extend if there's something more you need.

You could use Tiny-JSON

 string json = "{\"key1\":\"value1\", \"key2\":\"value2\"}"; IDictionary<string, string> dict = Tiny.Json.Decode<Dictionary<string, string>>(json);