কিভাবে আমি ASP.NET এ একটি সাধারণ অভিধান<string, string> এ JSON কে হতাশ করতে পারি?




asp.net-ajax asp.net-3.5 (13)

Json.NET এই কাজ করে ...

string json = @"{""key1"":""value1"",""key2"":""value2""}";

var values = JsonConvert.DeserializeObject<Dictionary<string, string>>(json);

আরো উদাহরণ: Json.NET এর সাথে সিরিয়ালাইজেশন সংগ্রহ

আমার পোষ্টের মাধ্যমে ASP.NET এ ফিরে পাঠানো হচ্ছে JSON এ একটি সহজ কী / মান তালিকা আছে। উদাহরণ:

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

আমি কঠোরভাবে টাইপ করা। নেট অবজেক্টের মধ্যে ডিজাইনার করার চেষ্টা করছি না।

আমি কেবল একটি সাধারণ পুরানো অভিধান (স্ট্রিং, স্ট্রিং) , অথবা কিছু সমতুল্য (হ্যাশ টেবিল, অভিধান (স্ট্রিং, অবজেক্ট), পুরানো-স্কুল স্ট্রিংস্কি-নরকের প্রয়োজন, জাহিরের একটি 2-D অ্যারের আমার জন্য কাজ করবে।

আমি ASP.NET 3.5 এ উপলব্ধ কিছু ব্যবহার করতে পারি, সেইসাথে জনপ্রিয় Json.NET (যা আমি ইতিমধ্যে ক্লায়েন্টের সিরিয়ালাইজেশনের জন্য ব্যবহার করছি)।

দৃশ্যত এই JSON লাইব্রেরীর মধ্যেও এই কপালটি স্পষ্টভাবে বাক্সের বাইরে নেই - তারা দৃঢ় চুক্তির মাধ্যমে প্রতিফলন-ভিত্তিক deserialization উপর সম্পূর্ণরূপে দৃষ্টি নিবদ্ধ করা হয়।

কোন ধারনা?

সীমাবদ্ধতা:

  1. আমি আমার নিজের JSON পার্সার বাস্তবায়ন করতে চান না
  2. এখনও ASP.NET 4.0 ব্যবহার করতে পারবেন না
  3. JSON এর জন্য পুরানো, অব্যবহৃত ASP.NET ক্লাস থেকে দূরে থাকতে চাই

আপনি লাইটওয়েট, নন-অ্যাড-রেফারেন্সের পদ্ধতির পদ্ধতির পরে থাকেন তবে আমি এই মাত্র কয়েকটি কোড লিখেছি যা কাজ করবে (যদিও আমি 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 মধ্যে অন্যান্য প্রশ্নের উত্তর নল জন্য একটি চেক যোগ

আমি একই সমস্যা ছিল তাই আমি এই আমার লিখেছেন। এই সমাধানটি অন্যান্য উত্তরগুলির থেকে আলাদা করা হয় কারণ এটি একাধিক স্তরে ডেসারিয়ালাইজ করতে পারে।

শুধু deserializeToDictionary ফাংশনে JSON স্ট্রিং পাঠান এটি অযৌক্তিক -টাইপ করা Dictionary<string, 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;
}

পূর্ব: এটি Dictionary<string, object> একটি ফেসবুক JSON প্রতিক্রিয়া অবজেক্ট প্রদান করবে।

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।


আমি আবিষ্কার করেছি। নেটওয়ার্কে JSON স্ট্রিংটিকে Dictionary<String, Object> System.Web.Script.Serialization.JavaScriptSerializerSystem.Web.Script.Serialization.JavaScriptSerializer টাইপের মাধ্যমে JSON স্ট্রিংটি কাস্ট করার উপায় তৈরি করেছে 3.5 System.Web.Extensions । ওয়েব System.Web.Extensions সমাবেশ। পদ্ধতি DeserializeObject(String) ব্যবহার করুন।

আমি স্ট্যাটিক। নেট পেইজ মেথডের কন্টেন্ট টাইপ 'অ্যাপ্লিকেশন / জসন' এর AJAX পোস্ট (জ্যাকচারির মাধ্যমে) করার সময় এটির উপর ঝাপসা পড়েছিলাম এবং দেখেছি যে পদ্ধতি (যা টাইপ Object একক প্যারামিটার ছিল) এই অভিধানটিকে জাদু করে।


আমি এখানে JSNake04 এবং Dasun দ্বারা জমা কোড উপর যোগ করেছেন। আমি 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;
}

আমি শুধু RestSharp এই বাস্তবায়িত। এই পোস্টটি আমার সহায়ক ছিল।

লিংক কোড ছাড়াও, এখানে আমার কোড। যখন আমি এমন কিছু করি তখন আমি এখন একটি 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 আশা করছেন তার বিষয়ে সতর্ক থাকুন - আমার ক্ষেত্রে, আমি বিভিন্ন বৈশিষ্ট্যের সাথে একক বস্তু পুনরুদ্ধার করছিলাম। সংযুক্ত লিঙ্ক, লেখক একটি তালিকা পুনরুদ্ধার করা হয়।


কোন বহিরাগত 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);

মনে হচ্ছে এখানে এই সমস্ত উত্তর মনে হচ্ছে যে আপনি একটি বড় বস্তুর থেকে ছোট স্ট্রিংটি পেতে পারেন ... কারণ মানুষরা ম্যাপিংয়ের ভিতরে কোথাও এমন একটি অভিধানের সাথে বড় বস্তুকে অযৌক্তিকভাবে অবহেলা করতে চায় এবং সিস্টেমটি কে ব্যবহার করছে। System.Runtime.Serialization.Json 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
    }
}

ক্লাসে নতুন সমর্থিত ধরনের যোগ করার জন্য, আপনাকে অবশ্যই আপনার বর্গ যুক্ত করতে হবে, এটি সঠিক কন্সট্রাক্টর এবং ফাংশনগুলি দিতে হবে (উদাহরণস্বরূপ JsonSurrogateObject ), নিশ্চিত করুন যে এটি JsonSurrogateObject উত্তরাধিকারী, এবং JsonSurrogateObject অভিধানে তার টাইপ ম্যাপিং যুক্ত করুন। অন্তর্ভুক্ত surrogateDictionary কোন Dictionary<String,T> প্রকারের জন্য ভিত্তি হিসাবে পরিবেশন করতে পারে যেখানে টি সঠিকভাবে deserialize যে কোনো ধরনের হয়।

এটা কলিং সত্যিই সহজ:

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

উল্লেখ্য যে কিছু কারণে এই জিনিসটি কী স্ট্রিং ব্যবহার করে সমস্যা রয়েছে যা স্পেস ধারণ করে; তারা কেবল চূড়ান্ত তালিকায় উপস্থিত ছিল না। শুধু জেসন চশমাগুলির বিরুদ্ধে এটি কেবলমাত্র হতে পারে এবং আমি যে API এ কল করেছি সেটি দুর্বলভাবে প্রয়োগ করা হয়েছে, মনে রাখবেন; আমি জানিনা. যাইহোক, আমি রেজেক্স দ্বারা এটি সমাধান করেছি - কাঁচা জসন ডেটাতে আন্ডারস্কোরগুলি দিয়ে তাদের প্রতিস্থাপন এবং deserialization পরে অভিধানটি স্থির করে।


যারা ইন্টারনেট অনুসন্ধান করে এবং এই পোস্টে stumbling জন্য, আমি জাভাস্ক্রিপ্ট Serializer ক্লাস ব্যবহার করার জন্য একটি ব্লগ পোস্ট লিখেছেন।

আরও পড়ুন ... 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.NET ব্যবহার করে গৃহীত উত্তরটি আরো সহজতর। কাউকে বিসিএল শুধুমাত্র কোড প্রয়োজন হলে এই এক ছেড়ে।

এটি বাক্সের বাইরে .NET ফ্রেমওয়ার্ক দ্বারা সমর্থিত নয়। একটি glaring oversight - প্রত্যেকের নামযুক্ত বৈশিষ্ট্য সঙ্গে বস্তুর মধ্যে deserialize করতে হবে না। তাই আমি আমার নিজের ঘূর্ণায়মান শেষ পর্যন্ত:

<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"]);

C # এবং VB.NET এর মিশ্রণের জন্য দুঃখিত ...


বিরক্তিকর যথেষ্ট, যদি আপনি ডিফল্ট মডেল বাইন্ডারগুলি ব্যবহার করতে চান তবে মনে হচ্ছে আপনাকে সংখ্যাসূচক সূচক মানগুলি একটি ফর্ম পোস্টের মতো ব্যবহার করতে হবে।

এই নিবন্ধটি থেকে নিচের অংশটি দেখুন http://msdn.microsoft.com/en-us/magazine/hh781022.aspx :

যদিও এটি কিছুটা প্রতিক্রিয়াশীল, তবে JSON অনুরোধগুলির একই প্রয়োজনীয়তা রয়েছে-তারাও, ফর্ম পোস্ট নামকরণ সিন্ট্যাক্সের মেনে চলতে হবে। উদাহরণস্বরূপ, পূর্ববর্তী ইউনিটপ্রাইস সংগ্রহের জন্য 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
}

জটিল অবজেক্ট সংগ্রহের দৃশ্য সম্ভবত সর্বাধিক ব্যাপক সমস্যাযুক্ত পরিস্থিতিতে একটি যা ডেভেলপারগুলি চালায় কারণ সিনট্যাক্স সমস্ত ডেভেলপারদের জন্য প্রয়োজনীয় নয়। তবে, একবার জটিল সংগ্রহ পোস্ট করার জন্য আপনি তুলনামূলকভাবে সহজ সিনট্যাক্সটি শিখেন, তখন এই পরিস্থিতিগুলি মোকাবেলা করা অনেক সহজ হয়ে যায়।


আপনি Tiny-JSON ব্যবহার করতে পারেTiny-JSON

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

খেলার জন্য কিছুটা দেরিতে, কিন্তু উপরের সমাধানগুলির মধ্যে একটি আমাকে নিখুঁত এবং সহজ .NET, কোন json.net সমাধানের দিকে নির্দেশ করে। তাই এখানে এটি, খুব সহজ হচ্ছে সমাপ্ত। স্ট্যান্ডার্ড নেট। জেসন সিরিয়ালাইজেশনের সাথে এটি কীভাবে সম্পন্ন করা হয় তার সম্পূর্ণ চলমান উদাহরণের নীচে, উদাহরণটিতে মূল বস্তু এবং শিশু বস্তুর উভয় অভিধান রয়েছে।

সোনালী বুলেট এই বিড়ালটি, সিরিয়ালাইজারকে দ্বিতীয় প্যারামিটার হিসাবে সেটিংস বিশ্লেষণ করে:

DataContractJsonSerializerSettings settings =
                       new DataContractJsonSerializerSettings();
                    settings.UseSimpleDictionaryFormat = true;

নীচের সম্পূর্ণ কোড:

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;

    namespace Kipon.dk
    {
        public class JsonTest
        {
            public const string EXAMPLE = @"{
                ""id"": ""some id"",
                ""children"": {
                ""f1"": {
                    ""name"": ""name 1"",
                    ""subs"": {
                    ""1"": { ""name"": ""first sub"" },
                    ""2"": { ""name"": ""second sub"" }
                    }
                },
                ""f2"": {
                    ""name"": ""name 2"",
                    ""subs"": {
                    ""37"": { ""name"":  ""is 37 in key""}
                    }
                }
                }
            }
            ";

            [DataContract]
            public class Root
            {
                [DataMember(Name ="id")]
                public string Id { get; set; }

                [DataMember(Name = "children")]
                public Dictionary<string,Child> Children { get; set; }
            }

            [DataContract]
            public class Child
            {
                [DataMember(Name = "name")]
                public string Name { get; set; }

                [DataMember(Name = "subs")]
                public Dictionary<int, Sub> Subs { get; set; }
            }

            [DataContract]
            public class Sub
            {
                [DataMember(Name = "name")]
                public string Name { get; set; }
            }

            public static void Test()
            {
                var array = System.Text.Encoding.UTF8.GetBytes(EXAMPLE);
                using (var mem = new System.IO.MemoryStream(array))
                {
                    mem.Seek(0, System.IO.SeekOrigin.Begin);
                    DataContractJsonSerializerSettings settings =
                       new DataContractJsonSerializerSettings();
                    settings.UseSimpleDictionaryFormat = true;

                    var ser = new DataContractJsonSerializer(typeof(Root), settings);
                    var data = (Root)ser.ReadObject(mem);
                    Console.WriteLine(data.Id);
                    foreach (var childKey in data.Children.Keys)
                    {
                        var child = data.Children[childKey];
                        Console.WriteLine(" Child: " + childKey + " " + child.Name);
                        foreach (var subKey in child.Subs.Keys)
                        {
                            var sub = child.Subs[subKey];
                            Console.WriteLine("   Sub: " + subKey + " " + sub.Name);
                        }
                    }
                }
            }
        }
    }




json.net