C# json使用之Json.NET（4）——LINQ to JSON

最新推荐文章于 2024-09-06 19:49:16 发布
最新推荐文章于 2024-09-06 19:49:16 发布
阅读量1.2k 收藏 1
点赞数 1
分类专栏： C# 文章标签： json c# .net
原文链接：https://www.newtonsoft.com/json/help/html/LINQtoJSON.htm
版权

LINQ to JSON是一个用于处理JSON对象的API。 它的设计考虑了LINQ，以便快速查询和创建JSON对象。 LINQ to JSON位于Newtonsoft.Json.Linq命名空间下。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
JObject o = JObject.Parse(@"{
  'CPU': 'Intel',
  'Drives': [
    'DVD read/writer',
    '500 gigabyte hard drive'
  ]
}");
 
string cpu = (string)o["CPU"];
// Intel
 
string firstDrive = (string)o["Drives"][0];
// DVD read/writer
 
IList<string> allDrives = o["Drives"].Select(t => (string)t).ToList();
// DVD read/writer
// 500 gigabyte hard drive

解析JSON

LINQ to JSON具有可用于从字符串解析JSON或直接从文件加载JSON的方法。

Parsing JSON text 解析JSON文本

可以使用Parse（String）从字符串中读取JSON值。

1
2
3
4
5
6
7
8
9
string json = @"{
  CPU: 'Intel',
  Drives: [
    'DVD read/writer',
    '500 gigabyte hard drive'
  ]
}";
 
JObject o = JObject.Parse(json);
1
2
3
4
5
6
7
string json = @"[
  'Small',
  'Medium',
  'Large'
]";
 
JArray a = JArray.Parse(json);

Loading JSON from a file 从文件加载JSON

也可以使用ReadFrom（JsonReader）直接从文件加载JSON。

1
2
3
4
5
using (StreamReader reader = File.OpenText(@"c:\person.json"))
{
    JObject o = (JObject)JToken.ReadFrom(new JsonTextReader(reader));
    // do stuff
}

创建JSON

除了从现有JSON字符串解析JSON之外，还可以从头创建LINQ to JSON对象以创建新的JSON结构。

手动创建json

一次设置一个值并创建一个对象和数组可以完全控制，但它比其他选项更冗长。

1
2
3
4
5
6
7
8
9
10
11
12
JArray array = new JArray();
JValue text = new JValue("Manual text");
JValue date = new JValue(new DateTime(2000, 5, 23));
 
array.Add(text);
array.Add(date);
 
string json = array.ToString();
// [
//   "Manual text",
//   "2000-05-23T00:00:00"
// ]

使用LINQ创建JSON

使用LINQ声明性地创建JSON对象是从值集合创建JSON的快速方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
List<Post> posts = GetPosts();
 
JObject rss =
    new JObject(
        new JProperty("channel",
            new JObject(
                new JProperty("title", "James Newton-King"),
                new JProperty("link", "http://james.newtonking.com"),
                new JProperty("description", "James Newton-King's blog."),
                new JProperty("item",
                    new JArray(
                        from p in posts
                        orderby p.Title
                        select new JObject(
                            new JProperty("title", p.Title),
                            new JProperty("description", p.Description),
                            new JProperty("link", p.Link),
                            new JProperty("category",
                                new JArray(
                                    from c in p.Categories
                                    select new JValue(c)))))))));
 
Console.WriteLine(rss.ToString());
 
//{
//  "channel": {
//    "title": "James Newton-King",
//    "link": "http://james.newtonking.com",
//    "description": "James Newton-King\'s blog.",
//    "item": [
//      {
//        "title": "Json.NET 1.3 + New license + Now on CodePlex",
//        "description": "Annoucing the release of Json.NET 1.3, the MIT license and being available on CodePlex",
//        "link": "http://james.newtonking.com/projects/json-net.aspx",
//        "category": [
//          "Json.NET",
//          "CodePlex"
//        ]
//      },
//      {
//        "title": "LINQ to JSON beta",
//        "description": "Annoucing LINQ to JSON",
//        "link": "http://james.newtonking.com/projects/json-net.aspx",
//        "category": [
//          "Json.NET",
//          "LINQ"
//        ]
//      }
//    ]
//  }
//}

从对象创建JSON

最后一个选项是使用FromObject（）方法从非JSON类型创建JSON对象。 在内部，FromObject将使用JsonSerializer将对象序列化为LINQ to JSON对象而不是文本。

下面的示例显示了从匿名对象创建JSON对象，但任何.NET类型都可以与FromObject一起使用来创建JSON。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
JObject o = JObject.FromObject(new
{
    channel = new
    {
        title = "James Newton-King",
        link = "http://james.newtonking.com",
        description = "James Newton-King's blog.",
        item =
            from p in posts
            orderby p.Title
            select new
            {
                title = p.Title,
                description = p.Description,
                link = p.Link,
                category = p.Categories
            }
    }
});

使用LINQ查询JSON

LINQ to JSON提供了许多从其对象获取数据的方法。 JObject / JArray上的索引方法允许您通过其属性名称快速获取数据集合中的对象或索引，而Children（）允许您获取数据范围作为IEnumerable <JToken>然后使用LINQ进行查询。

Getting values by Property Name or Collection Index

从LINQ到JSON获取值的最简单方法是使用JObject / JArray上的Item [Object]索引，然后将返回的JValue转换为所需的类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
string json = @"{
  'channel': {
    'title': 'James Newton-King',
    'link': 'http://james.newtonking.com',
    'description': 'James Newton-King\'s blog.',
    'item': [
      {
        'title': 'Json.NET 1.3 + New license + Now on CodePlex',
        'description': 'Annoucing the release of Json.NET 1.3, the MIT license and the source on CodePlex',
        'link': 'http://james.newtonking.com/projects/json-net.aspx',
        'categories': [
          'Json.NET',
          'CodePlex'
        ]
      },
      {
        'title': 'LINQ to JSON beta',
        'description': 'Annoucing LINQ to JSON',
        'link': 'http://james.newtonking.com/projects/json-net.aspx',
        'categories': [
          'Json.NET',
          'LINQ'
        ]
      }
    ]
  }
}";
 
JObject rss = JObject.Parse(json);
 
string rssTitle = (string)rss["channel"]["title"];
// James Newton-King
 
string itemTitle = (string)rss["channel"]["item"][0]["title"];
// Json.NET 1.3 + New license + Now on CodePlex
 
JArray categories = (JArray)rss["channel"]["item"][0]["categories"];
// ["Json.NET", "CodePlex"]
 
IList<string> categoriesText = categories.Select(c => (string)c).ToList();
// Json.NET
// CodePlex

用LINQ查询

也可以使用LINQ查询JObject / JArray。 Children（）将JObject / JArray的子元素值作为IEnumerable <JToken>返回，然后可以使用标准的Where / OrderBy / Select LINQ运算符进行查询。

Children（）返回令牌的所有子节点。 如果它是一个JObject，它将返回一个要使用的属性集合，如果它是一个JArray，您将获得该数组值的集合。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
var postTitles =
    from p in rss["channel"]["item"]
    select (string)p["title"];
 
foreach (var item in postTitles)
{
    Console.WriteLine(item);
}
 
//LINQ to JSON beta
//Json.NET 1.3 + New license + Now on CodePlex
 
var categories =
    from c in rss["channel"]["item"].SelectMany(i => i["categories"]).Values<string>()
    group c by c
    into g
    orderby g.Count() descending
    select new { Category = g.Key, Count = g.Count() };
 
foreach (var c in categories)
{
    Console.WriteLine(c.Category + " - Count: " + c.Count);
}
 
//Json.NET - Count: 2
//LINQ - Count: 1
//CodePlex - Count: 1

LINQ to JSON也可用于手动将JSON转换为.NET对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Shortie
{
    public string Original { get; set; }
    public string Shortened { get; set; }
    public string Short { get; set; }
    public ShortieException Error { get; set; }
}
 
public class ShortieException
{
    public int Code { get; set; }
    public string ErrorMessage { get; set; }
}

当您使用与您的.NET对象不匹配的JSON时，在.NET对象之间手动序列化和反序列化非常有用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
string jsonText = @"{
  'short': {
    'original': 'http://www.foo.com/',
    'short': 'krehqk',
    'error': {
      'code': 0,
      'msg': 'No action taken'
    }
  }
}";
 
JObject json = JObject.Parse(jsonText);
 
Shortie shortie = new Shortie
{
    Original = (string)json["short"]["original"],
    Short = (string)json["short"]["short"],
    Error = new ShortieException
    {
        Code = (int)json["short"]["error"]["code"],
        ErrorMessage = (string)json["short"]["error"]["msg"]
    }
};
 
Console.WriteLine(shortie.Original);
// http://www.foo.com/
 
Console.WriteLine(shortie.Error.ErrorMessage);
// No action taken

使用SelectToken查询JSON

SelectToken（）提供了一种方法，使用指向所需JToken的单个字符串路径来查询LINQ to JSON。 SelectToken使动态查询变得容易，因为整个查询是在字符串中定义的。

SelectToken

SelectToken是JToken上的一个方法，它采用字符串路径到子令牌。 如果在路径的位置找不到令牌，则SelectToken将返回子令牌或空引用。

该路径由以句点分隔的属性名称和数组索引组成，例如：Manufacturers[0].Name。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
JObject o = JObject.Parse(@"{
  'Stores': [
    'Lambton Quay',
    'Willis Street'
  ],
  'Manufacturers': [
    {
      'Name': 'Acme Co',
      'Products': [
        {
          'Name': 'Anvil',
          'Price': 50
        }
      ]
    },
    {
      'Name': 'Contoso',
      'Products': [
        {
          'Name': 'Elbow Grease',
          'Price': 99.95
        },
        {
          'Name': 'Headlight Fluid',
          'Price': 4
        }
      ]
    }
  ]
}");
 
string name = (string)o.SelectToken("Manufacturers[0].Name");
// Acme Co
 
decimal productPrice = (decimal)o.SelectToken("Manufacturers[0].Products[0].Price");
// 50
 
string productName = (string)o.SelectToken("Manufacturers[1].Products[0].Name");
// Elbow Grease

SelectToken with JSONPath

SelectToken支持JSONPath查询。 在此处了解有关JSONPath的更多信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
JObject o = JObject.Parse(@"{
  'Stores': [
    'Lambton Quay',
    'Willis Street'
  ],
  'Manufacturers': [
    {
      'Name': 'Acme Co',
      'Products': [
        {
          'Name': 'Anvil',
          'Price': 50
        }
      ]
    },
    {
      'Name': 'Contoso',
      'Products': [
        {
          'Name': 'Elbow Grease',
          'Price': 99.95
        },
        {
          'Name': 'Headlight Fluid',
          'Price': 4
        }
      ]
    }
  ]
}");
 
// manufacturer with the name 'Acme Co'
JToken acme = o.SelectToken("$.Manufacturers[?(@.Name == 'Acme Co')]");
 
Console.WriteLine(acme);
// { "Name": "Acme Co", Products: [{ "Name": "Anvil", "Price": 50 }] }
 
// name of all products priced 50 and above
IEnumerable<JToken> pricyProducts = o.SelectTokens("$..Products[?(@.Price >= 50)].Name");
 
foreach (JToken item in pricyProducts)
{
    Console.WriteLine(item);
}
// Anvil
// Elbow Grease

SelectToken with LINQ

SelectToken可与标准LINQ方法结合使用。

1
2
3
4
5
6
7
8
9
10
IList<string> storeNames = o.SelectToken("Stores").Select(s => (string)s).ToList();
// Lambton Quay
// Willis Street
 
IList<string> firstProductNames = o["Manufacturers"].Select(m => (string)m.SelectToken("Products[1].Name")).ToList();
// null
// Headlight Fluid
 
decimal totalPrice = o["Manufacturers"].Sum(m => (decimal)m.SelectToken("Products[0].Price"));
// 149.9
JSON使用Linq序列化与反序列化.NET类型
lovegonghui的专栏
12-15 1405
1.先创建一个json字符串,用转换成JArray数组,然后创建一个Post对象.把这个对象添加到List列表中. using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Data; using System.Web; using GongHu
C#解析json的Newtonsoft.Json.dll各种.net版本
03-07
.NET 3.5版本同样支持Newtonsoft.Json.dll，开发者可以使用Json.NET的特性，例如JsonConverter，自定义JSON序列化行为。此外，还有JObject、JArray和JToken等LINQ to JSON API，可以直接操作JSON结构。 3. **.NET ...
c# Newtonsoft.Json 使用 LINQ 查询 JSON 数据
最新发布
weixin_39604653的博客
09-06 512
在 C# 中，Newtonsoft.Json 提供了与 LINQ（Language Integrated Query）结合使用的强大功能，可以轻松地查询、过滤和操作 JSON 数据。通过使用 JObject 和 JArray，你可以通过 LINQ 查询 JSON 对象和数组。
Linq To Json
04-09 110
Linq to Json 基本Linq的都差不多,可以参考Json.net文档.这个并未深入研究 string str = "{title:123,body:456,list:{title:'这是一个标题',body:'what'}}"; JObject o = JObject.Parse(str); var s = from p in o.Chil...
Linq to json
weixin_30580341的博客
12-03 79
添加引用： using Newtonsoft.Json.Linq;using System.Collections.Generic; 操作json字符串方法 /// <summary> /// linq操作json /// </summary> public void OpearteJson() { ...
C# Newtonsoft.Json之LINQ To Json实例(一)
热门推荐
天马3798
09-09 3万+
一、LINQ to JSON 常用实例1： JObject o = JObject.Parse(@"{ 'CPU': 'Intel', 'Drives': [ 'DVD read/writer', '500 gigabyte hard drive' ] }"); string cpu = (string)o["CPU"]; Console.Wr
Json.Net系列教程 Linq To JSON
wvtjplh的专栏
07-14 192
一.Linq to JSON是用来干什么的? 　　Linq to JSON是用来操作JSON对象的.可以用于快速查询,修改和创建JSON对象.当JSON对象内容比较复杂,而我们仅仅需要其中的一小部分数据时,可以考虑使用Linq to JSON来读取和修改部分的数据而非反序列化全部. 二.创建JSON数组和对象 在进行Linq to JSON之前,首先要了解一下用于操作Linq to JSON的类. 类名 说明 JObject 用于操作JSON对象 .
c# Json库 （.NET2.0）
09-04
5. **LINQ to JSON**：Json.NET的另一个强大特性是支持LINQ查询，允许你像操作XML一样操作JSON数据。例如，查找年龄大于30的人： ```csharp JArray people = JArray.Parse("[{\"Name\":\"张三\",\"Age\":30}, {\...
Newtonsoft.Json .net framework4.0版
10-30
它还支持JSON.NET特性，如 `[JsonProperty]`、`[JsonConverter]` 等，用于自定义序列化行为。 **6. 性能优化** 由于.NET Framework 4.0的限制，此版本可能没有利用到后来版本中的性能改进。然而，即便如此，...
Json.NET使用入门(六)【LINQ to JSON】
极客神殿
11-25 1286
手动创建JSON本示例以编程方式一次创建JObject和JArray实例。 JArray array = new JArray(); array.Add("Manual text"); array.Add(new DateTime(2000, 5, 23)); JObject o = new JObject(
Newtonsoft.Json.Net的各个版本适用.net2.0 .net3.5 .net4.0 .net4.5
03-08
Newtonsoft.Json.Net库提供了一套全面、高效的API，使得在C#、VB.NET或其他.NET语言中序列化和反序列化JSON变得非常简单。 标题中提到的"Newtonsoft.Json.Net的各个版本适用.net2.0 .net3.5 .net4.0 .net4.5"，意味...
Linq To JSON
qq_31971935的博客
03-29 431
界面引用：http://www.cnblogs.com/usharei/archive/2012/04/24/2467578.html一.Linq to JSON是用来干什么的?　　Linq to JSON是用来操作JSON对象的.可以用于快速查询,修改和创建JSON对象.当JSON对象内容比较复杂,而我们仅仅需要其中的一小部分数据时,可以考虑使用Linq to JSON来读取和修改部分的数据而非反
LINQto JSON
QQ289172257的专栏
09-28 771
一 .使用 mircosoft 提供的 .NET Framework 自带的 json操作方法 [] 与  {} 在 JSON 里 [] 是 Array {} 是Ojbect [] Array 的key 是 int. {} 的key 是 string
利用Linq 处理Json数组(Linq to json)
DHZYKN
05-15 1243
以下是一个例子： 因为客户端没有创建相应的实体对象，需要客户端直接分析json 接口返回一个集合，序列化成json后，再转成JArray，然后利用Linq进行分组转换 string json = JsonConvert.SerializeObject(data); JArray jArray = JArray.Parse(json); var dataView = (from jt in jArray group jt by jt.Value&
linq to json
weixin_30814329的博客
09-13 148
一、linq操用json数据的简单使用方法 1、json数据 {"orgInfo":{"ORG_NAME":"A2项目组","ORG_ID":"01DBDDE2F8A64B4BA88D25D94A88951E"},"postInfo":["A2测试岗位","A2井筒工程审核岗"],"userInfo":{"USER_NAME":"开发人 员","USER_CODE":"kfry"...
使用Newtonsoft直接读取Json格式文本（Linq to Json）
YSの陈憨憨
07-24 2124
如果你使用 Visual Studio，可以右键点击项目，选择“管理 NuGet 程序包”，然后搜索并安装 Newtonsoft.Json。使用 Newtonsoft.Json（通常简称为 Newtonsoft）可以轻松地处理 JSON 格式的文本。Newtonsoft.Json 是 .NET 中一个流行的 JSON 处理库，它提供了丰富的功能和灵活性。通过使用 Newtonsoft.Json，你可以灵活地读取和解析 JSON 格式的文本，并方便地提取所需的数据。，然后通过键值索引的方式获取其中的属性值。
Json.Net之Linq To JSON
笨笨鸟吃柠檬的专栏
10-26 759
一.Linq to JSON是用来干什么的? Linq to JSON是用来操作JSON对象的.可以用于快速查询,修改和创建JSON对象.当JSON对象内容比较复杂,而我们仅仅需要其中的一小部分数据时,可以考虑使用Linq to JSON来读取和修改部分的数据而非反序列化全部. 二.创建JSON数组和对象 在进行Linq to JSON之前,首先要了解一下用于操作Linq
Newtonsoft.Json.dll .net3.5专用.rar
07-30
5. **LINQ to JSON**：提供了类似LINQ的API来查询和操作JSON文档，使处理JSON变得简单直观。 6. **配置选项**：Newtonsoft.Json提供了许多配置选项，如日期格式化、空值处理、命名策略等，可以调整以满足不同需求。...
C#使用Newtonsoft直接读取Json格式文本（Linq to Json）
zls365365的博客
12-02 1810
Newtonsoft是比较老的Json序列化和反序列化API，但是版本并不老，它完美的支持.NET Core以上版本。其实Newtonsoft除了序列化功能，还可以实现LINQ to JSON的功能，也就是不依赖对象（相对），用LINQ的方式直接读取json文本，这样的好处是，动态读取Json的时候如果对象不同字段名称相同就可以不依赖对象了。使用方法1、环境准备新建一个.NET6项目，安装...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值