JSON C # ගතික වස්තුවක් බවට පත් කරන්න?

JSON අන්තර්ගතය C # 4 ගතික වර්ගයක් බවට පත්කිරීමට ක්‍රමයක් තිබේද? භාවිතා කිරීම සඳහා පන්ති පොකුරක් නිර්මාණය කිරීම මඟ හැරීම සතුටක් DataContractJsonSerializer.

System.Web.Helpersඑකලස් කිරීම මත යැපීම ගැන ඔබ සතුටු වන්නේ නම්, ඔබට Jsonපන්තිය භාවිතා කළ හැකිය :

dynamic data = Json.Decode(json);

.NET 4 රාමුවට අතිරේක බාගත කිරීමක් ලෙස එය MVC රාමුව සමඟ ඇතුළත් කර ඇත . එය ප්‍රයෝජනවත් නම් ව්ලැඩ්ට ඉහළට යාමට වග බලා ගන්න! කෙසේ වෙතත් ඔබට සේවාදායක පරිසරයට මෙම ඩීඑල්එල් ඇතුළත් යැයි උපකල්පනය කළ නොහැකි නම්, කියවන්න.

විකල්ප ආසියානුකරණ ප්‍රවේශයක් මෙහි යෝජනා කෙරේ . දෝෂයක් නිවැරදි කර මගේ කේතීකරණ ශෛලියට ගැලපෙන පරිදි මම කේතය තරමක් වෙනස් කළෙමි. ඔබට අවශ්‍ය වන්නේ මෙම කේතය සහ 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)

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 විමසීම

System.Web.Helpers.Json භාවිතයෙන් ඔබට මෙය කළ හැකිය - එහි විකේතන ක්‍රමය මඟින් ඔබට අවශ්‍ය පරිදි ගමන් කළ හැකි ගතික වස්තුවක් ලබා දෙයි.

එය System.Web.Helpers එකලස් කිරීම (.NET 4.0) හි ඇතුළත් කර ඇත.

var dynamicObject = Json.Decode(jsonString);

.NET 4.0 සඳහා මෙය සඳහා පුස්තකාලයක් ඇත:

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

මෙය සරලම ක්‍රමයයි.

කිසිදු තෙවන පාර්ශවීය ඩීඑල්එල් ගොනුවක් නොමැතිව විරෝධය දැක්වීමට සරල “නූල් 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);

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

Expando Objects භාවිතා කරන DynamicJsonConverter හි නව සංස්කරණයක් මම සාදන ලදී. මම පුළුල් කිරීමේ වස්තු භාවිතා කළෙමි, මන්ද මට 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) })); }
        }
    }
}

Newtonsoft.Json භාවිතා කරන තවත් ක්‍රමයක් :

dynamic stuff = Newtonsoft.Json.JsonConvert.DeserializeObject("{ color: 'red', value: 5 }");
string color = stuff.color;
int value = stuff.value;

නිව්ටන්සොෆ්ට් ජේසන්ගේ සහාය ඇතිව ඔබට එය සාක්ෂාත් කරගත හැකිය. නුගෙට් වෙතින් නිව්ටන්සොෆ්ට්.ජේසන් ස්ථාපනය කරන්න සහ:

using Newtonsoft.Json;

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

සරලම ක්‍රමය නම්:

මෙම ඩීඑල්එල් ගොනුව ඇතුළත් කරන්න .

මේ වගේ කේතය භාවිතා කරන්න:

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.

මම භාවිතා කරන්නේ http://json2csharp.com/JSON වස්තුව නියෝජනය කරන පන්තියක් ලබා ගැනීමට .

ආදානය:

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

පංතිය පිරවීම සඳහා මම නිව්ටන්සොෆ්ට් ජේසන් භාවිතා කරමි :

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

PS:

ඔබේ 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; }
}

වස්තූන් (ය) පුළුල් කිරීම සඳහා එය නිර්මාණය කළ ශබ්ද කෝෂය පුනරාවර්තනය කිරීමට ඔබට ජාවාස්ක්‍රිප්ට්සීරයිසර් දිගු කළ හැකි අතර පසුව ඒවා ගතිකව භාවිතා කළ හැකිය:

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

ඔයාට පාවිච්චි කරන්න පුළුවන් using Newtonsoft.Json

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

resolvedEvent.Event.Data මූලික සිදුවීම ඇමතීමෙන් මගේ ප්‍රතිචාරය ලැබේ.

ඒ සඳහා මම JSON.NET භාවිතා කර JSON ප්‍රවාහයේ පහත් මට්ටමේ විග්‍රහ කිරීම සිදු කර ExpandoObjectපන්තියේ අවස්ථා වලින් වස්තු ධූරාවලිය ගොඩනගා ගනිමි .

මම මගේ කේතයේ මේ ආකාරයට භාවිතා කරන අතර එය හොඳින් ක්‍රියාත්මක වේ

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

කෝඩ් ප්‍රොජෙක්ට් හි මා ලියූ ලිපිය දෙස බලන්න, ප්‍රශ්නයට හරියටම පිළිතුරු සපයන:

JSON.NET සමඟ ගතික වර්ග

මේ සියල්ල නැවත පළ කිරීම සඳහා ඕනෑවට වඩා ක්‍රමයක් ඇති අතර, එම ලිපියේ යතුර / අවශ්‍ය ප්‍රභව ගොනුව සමඟ ඇමුණුමක් ඇති බැවින් ඊටත් වඩා අඩු කරුණකි.

තවත් විකල්පයක් වන්නේ "JSON පන්ති ලෙස අලවන්න" එවිට එය ඉක්මණින් හා පහසුවෙන් ආශ්‍රිත කළ හැකිය.

1. ඔබේ සම්පූර්ණ JSON පිටපත් කරන්න
2. විෂුවල් ස්ටුඩියෝ දී: ක්ලික් කරන්න සංස්කරණය කරන්න → විශේෂ අලවන්න → ටියුශන් පන්ති ලෙස JSON අලවන්න

මෙන්න වඩා හොඳ පැහැදිලි කිරීමක් n piccas ... ASP.NET සහ වෙබ් මෙවලම් 2012.2 RC හි 'JSON පන්ති ලෙස අලවන්න'

JSON.NET හි ඩෙසරයිලයිසින් කිරීම 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());

සම්පූර්ණ උදාහරණයක් සඳහා ලිපිය බලන්න .

ඔබට අවශ්‍ය වස්තුව ඩයිනමික් JSONObject වෙබ්මාට්‍රික්ස් හි කොටසක් වන ASP.NET වෙබ් පිටු පැකේජයෙන් System.Web.Helpers.dll හි ඇතුළත් කර ඇත.

C # සඳහා SimpleJson නමින් සැහැල්ලු JSON පුස්තකාලයක් ඇත ඇත.

එය .NET 3.5+, සිල්වර් ලයිට් සහ වින්ඩෝස් දුරකථන 7 සඳහා සහය දක්වයි.

එය .NET 4.0 සඳහා ගතිකයට සහය දක්වයි

එය NuGet පැකේජයක් ලෙසද ස්ථාපනය කළ හැකිය

Install-Package SimpleJson

ජාවාස්ක්‍රිප්ට් සමඟ දත්තසෙට් (සී #) භාවිතා කරන්න. ඩේටාසෙට් ආදානය සමඟ 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;
}

ExpandoObject ලබා ගැනීම සඳහා:

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

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

මේක උත්සාහ කරන්න:

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

ගතික සහ JavaScriptSerializer සමඟ පහසු 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();
}

ගතික හා ජාවාස්ක්‍රිප්ට් සීරියලයිසර් සමඟ කැදැලි සහ සංකීර්ණ json විග්‍රහ කරන්නේ කෙසේද

කරුණාකර 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();
}

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

වියාචනය: මම මෙම පුස්තකාලයේ කර්තෘ වෙමි.

මේ ආකාරයෙන් උත්සාහ කරන්න!

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"]
        }]

සී # කේතය:

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

Newtonsoft.Json සමඟ ගතික වස්තු නිර්මාණය කිරීම ඇත්තෙන්ම විශිෂ්ටයි.

//json is your string containing the JSON value
dynamic data = JsonConvert.DeserializeObject<dynamic>(json);

දැන් ඔබට dataවස්තුව නිත්‍ය වස්තුවක් සේ ප්‍රවේශ විය හැකිය . මෙය දැනට අපට උදාහරණයක් ලෙස ඇති JSON වස්තුවයි:

{ "ID":123,"Name":"Jack","Numbers":[1, 2, 3] }

Deserialization පසු ඔබ එයට පිවිසෙන ආකාරය මෙයයි:

data.ID //Retrieve the int
data.Name //Retrieve the string
data.Numbers[0] //Retrieve the first element in the array