将JSON反序列化为C#动态对象?


965

有没有一种方法可以将JSON内容反序列化为C#4动态类型?跳过创建一堆类以使用会很好DataContractJsonSerializer


5
如果您想要“动态”的东西,为什么不使用大多数不用于普通对象的JSON解码器随附的get样式访问器呢?(例如,是否真的需要“动态”对象创建?)json.org有许多C#JSON实现的链接。

我正在一个项目中尝试将外部依赖性降到最低。因此,如果可能的话,最好使用.net序列化程序和类型的股票。当然,如果不可能的话,我要打json.org。谢谢!
jswanson 2010年

42
我真的很惊讶C#团队添加了“动态”,但是CLR中没有办法将JSON对象转换为动态CLR类实例。
Frank Schwieterman

2
不幸的是,接受的答案在.NET 4 RTM中不起作用。我发布了一个答案,可以帮助我着手解决这个问题,这可能对其他人有用。
德鲁·诺阿克斯

(尽管看上去Newtonsoft JSON.NET已经非常接近了。但是,没有真正好的例子。)
Hot Licks

Answers:


659

如果您愿意依赖该System.Web.Helpers程序集,则可以使用Json该类:

dynamic data = Json.Decode(json);

它包含在MVC框架中,作为对.NET 4框架的额外下载。如果有帮助,请务必给弗拉德投票!但是,如果您不能假定客户端环境包括此DLL,请继续阅读。


这里提出另一种反序列化方法。我稍稍修改了代码以修复错误并适合我的编码风格。您需要的只是此代码和System.Web.Extensions项目的引用:

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

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

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

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

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

    #region Nested type: DynamicJsonObject

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

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

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

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

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

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

            result = WrapResultObject(result);
            return true;
        }

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

                result = WrapResultObject(result);
                return true;
            }

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

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

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

            return result;
        }
    }

    #endregion
}

您可以像这样使用它:

string json = ...;

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

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

因此,给定一个JSON字符串:

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

以下代码将在运行时运行:

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

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

1
我在动态obj = serializer.Deserialize(json,typeof(object));中收到错误 说有2个参数的方法没有重载..错误的dll或什么?
Stewie Griffin

32
您可以使用System.Web.Helpers.Json-它提供了一个返回动态对象的Decode方法。我还发布了此信息作为答案。
弗拉德·伊利埃斯库

2
这也对我有很大帮助,但是我很好奇如果我需要使用.Serialize方法,该方法目前只抛出NotImplementedException,我该怎么办...我对密封类和/或扩展抽象不太熟悉类。谁能指出我正确的方向?
科里W.

2
有时在js中,您有带有特殊字符的字段,例如“ background-color”。要在js中访问此类字段,请执行obj [“ background-color”]。反序列化为动态对象后,如何从c#访问此类字段?我当然不能做obj.background-color,而且obj [“ background-color”]似乎不起作用。如果动态对象也可以像js一样同时作为字典来访问,那就太好了。
Radu Simionescu 2012年

2
@RaduSimionescu我可能有点晚了,但这也许对将来的访问者有所帮助。我遇到了同样的问题,只是字段名params(这是C#中的关键字)。除了TryGetMember可以覆盖之外TryGetIndex,它还提供与JS完全相同的行为。然后,您可以执行obj["params"]obj["background-color"]输入尴尬的字段名称。
Martin Ender 2013年

606

使用Json.NET非常简单:

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

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

另外using Newtonsoft.Json.Linq

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

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

文档:使用动态查询JSON


9
@HotLicks:要反思动态stuff,例如:foreach (Newtonsoft.Json.Linq.JProperty jproperty in stuff) { Console.WriteLine("jproperty.Name = {0}", jproperty.Name);}
Matthias

11
JsonConvert.DeserializeObject和JObject.Parse有什么区别?答案是,它们以相同的方式使用它们来做相同的事情,但没有解释区别。
2014年

7
@TomPeplow尝试过这个。它对我不起作用。它说“ JObject没有实现'Name'”。
李·路维耶


7
我无法使它正常工作。我将问题缩小到async方法内部。如果我使该方法同步,它将按预期工作。但是,使用该方法async,我无法获得dynamic,而我只能获得object。显式强制转换无济于事,仍然只给了我一个object。还有其他人遇到吗?
codeConcussion 2015年

295

您可以使用System.Web.Helpers.Json进行此操作-它的Decode方法返回一个动态对象,您可以根据需要遍历该对象。

它包含在System.Web.Helpers程序集(.NET 4.0)中。

var dynamicObject = Json.Decode(jsonString);

25
FYI System.Web.Helpers.dll需要.net 4.0,但不包含在.net 4.0中。可以与ASP.NET MVC 3一起安装
jbtule 2012年

7
您可以在Visual Studio 2012中的程序集下的“扩展”组中找到该程序集
2013年

1
使用动态有什么问题吗?如果输入的JSON不包含属性,我们如何有效地处理异常
。–

5
如果要强烈键入模型,请确保使用Json.Decode <T>(string)方法。
Mike

2
:这个库添加到您的项目stackoverflow.com/questions/8037895/...

80

.NET 4.0具有一个内置库来执行此操作:

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

这是最简单的方法。


27
你尝试过这个吗?它返回Dictionary<string,object>。除非我缺少某些内容,否则您的示例不会返回动态对象。
sergiopereira 2011年

18
这是行不通的,它只是以动态形式返回字典
mattmanser 2011年

55
@Peter Long我相信我未能清楚地陈述我的情况,亲爱的同伴。让我尝试纠正我的错误。我知道动态是什么。这不允许您传入JSON对象并使用d.code,必须执行d [“ code”]。Value,这不是大多数找到此答案的人想要的,我们已经知道如何获取字典并将其强制转换为动态对象会浪费时间。先生,我不同意。
mattmanser 2011年

4
@mattmanser ,we already know how to get the dictionary and casting it to a dynamic。它不一定是字典。杰森除了字典外还有其他清单。并且列表和字典也可以嵌套。我的代码可以处理所有这些情况。但是您的方法不能。
彼得·朗

4
@mattmanser是正确的;有可能实现 IDynamicMetaObjectProvider(或使用ExpandoObject)能够拦截属性并在内部字典中查找属性的方法。这与dynamic允许代码的使用结合d.code使用。将字典转换为动态字典是毫无意义的。
Stephen Drew 2014年

78

没有任何第三方DLL文件的简单对象“字符串JSON数据”:

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

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

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

注意:您也可以使用自定义对象。

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

4
我不明白。到目前为止,这是最简单的解决方案,没有人提及。
cikatomo

2
是的,它的简单:)有时你需要序列化,但不希望包括3部分DLL
易卜拉欣Özbölük

您能否详细说明:如何通过以下方式动态访问反序列化的对象myObject["myprop"]?我知道它是在运行时完成的,但是如何通过myObject["myprop"]有效访问它呢?
罗伊·纳米尔

1
您可以反序列化对象,例如Personel item = serializer.Deserialize <Personel>(getString);。如果您使用动态对象,你也可以使用数组,一切皆有可能就像everyobject
易卜拉欣Özbölük

3
要使用System.Web.Script.Serialization命名空间,您的项目需要对System.Web.Extensions的引用。
StilgarISCA

28

JsonFx可以将JSON内容反序列化为动态对象。

到/从动态类型序列化(.NET 4.0的默认设置):

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

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

19

我制作了使用Expando对象的DynamicJsonConverter的新版本。我使用了expando对象,因为我想使用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) })); }
        }
    }
}


13

您可以借助Newtonsoft.Json来实现。从Nuget安装Newtonsoft.Json和:

using Newtonsoft.Json;

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

8

最简单的方法是:

只需包含此DLL文件即可

使用如下代码:

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

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

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

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

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

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

6

您可以扩展JavaScriptSerializer,以递归方式复制它创建的字典以扩展对象,然后动态使用它们:

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

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

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

        return (ExpandoObject)expando;
    }
}

然后,您只需要在定义扩展名的名称空间中使用using语句即可(考虑只在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

6

您可以使用 using Newtonsoft.Json

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

resolvedEvent.Event.Data 是我从调用core Event得到的响应。


6

我使用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; }
}

之后,我使用Newtonsoft.Json来填充类:

using Newtonsoft.Json;

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

您可以这样称呼它:

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

string stringJson = JObjects.Get(jsonClass);

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

5

为此,我将使用JSON.NET进行JSON流的低级解析,然后从ExpandoObject该类的实例中构建对象层次结构。


5

我在我的代码中使用了这样,并且工作正常

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

1
但这不是问题要问的。当您必须为每个json字符串指定类型并使用动态类型时,情况有所不同。
Illuminati

5

看一下我在CodeProject上写的文章,该文章准确地回答了这个问题:

JSON.NET的动态类型

在这里重新发布所有内容的方法太多了,甚至更少,因为该文章带有密钥/必需的源文件的附件。



4

可以使用该JObject库中包含的类对JSON.NET中的反序列化进行动态处理。我的JSON字符串表示以下类:

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

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

现在,我们对字符串进行反序列化,而无需引用上述类:

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

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

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

或者,如果您想更进一步:

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

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

有关完整示例,请参见发布


这种方法允许“遍历” jSON文档,以便您可以管理未知JSON结构或变量(例如,发生错误时许多API返回完全不同的JSON文档)的情况。除了Newtonsoft.JSON(aka JSON.NET)之外,还有其他允许执行此操作的库?
亚历克斯75

4

您想要的DynamicJSONObject对象包含在ASP.NET Web Pages包的System.Web.Helpers.dll中,该包是WebMatrix的一部分。


4

C#有一个名为SimpleJson的轻量级JSON库。

它支持.NET 3.5 +,Silverlight和Windows Phone 7。

它支持.NET 4.0动态

它也可以作为NuGet软件包安装

Install-Package SimpleJson

4

将DataSet(C#)与JavaScript一起使用。一个简单的函数,用于使用DataSet输入创建JSON流。创建JSON内容,例如(多表数据集):

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

只是客户端,使用eval。例如,

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

然后使用:

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

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

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

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

3

要获取ExpandoObject:

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

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

3

尝试这个:

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

3

如何使用动态和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();
}

如何使用动态和JavaScriptSerializer解析嵌套和复杂的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();
}

1

使用Cinchoo ETL-可用于将JSON解析为动态对象的开源库:

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

输出:

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

免责声明:我是这个图书馆的作者。


0

尝试这种方式!

JSON示例:

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

C#代码:

        var jsonString = (File.ReadAllText(Path.Combine(Directory.GetCurrentDirectory(),"delete_result.json")));
        var objects = JsonConvert.DeserializeObject<dynamic>(jsonString);
        foreach(var o in objects)
        {
            Console.WriteLine($"{o.id.ToString()}");
        }
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.