正文

C#使用LINQ查询表达式的基本子句总结

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0708

这篇文章主要介绍了C#使用LINQ查询表达式的基本子句总结,在C#程序中我们可以使用LINQ基本查询表达式模式来查询和转换SQL数据库、ADO.NET数据集、XML文档和流以及.NET集合中的数据,需要的朋友可以参考下

linq查询表达式的基本语法很容易掌握，它使用c#常见的语言构造，从外观上看，和我们常用的sql类似，并且查询表达式中的变量可以用匿名类型，所以在很多情况下，不需要指定变量类型就可以构建linq表达式。

linq的数据源可以是数据库对象或是xml流等，也可以使实现了ienumerable或者泛型ienumberable<t>接口的集合对象。

linq的基本语法包含如下的8个上下文关键字，这些关键字和具体的说明如下：

关键字
说明
from 指定范围变量和数据源
where 根据bool表达式从数据源中筛选数据
select 指定查询结果中的元素所具有的类型或表现形式
group 对查询结果按照键值进行分组(igrouping<tkey,telement>)
into 提供一个标识符，它可以充当对join、group或select子句结果的引用
orderby 对查询出的元素进行排序(ascending/descending)
join 按照两个指定匹配条件来equals连接两个数据源
let 产生一个用于存储查询表达式中的子表达式查询结果的范围变量

下面依此总结这8个关键字的常用查询语句写法。

 

1.from子句
如果要写一个linq表达式，就必须是以from子句开头。个人觉得from子句中需要注意的地方就是多个from子句的书写。

?
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
using system;
using system.collections.generic;
using system.linq;
using system.text;
using system.collections;
 
namespace linq
{
  /// <summary>
  /// linq,重点是感悟from子句中的查询变量的灵活
  /// </summary>
  class program
  {
    static void main(string[] args)
    {
      //1单个form子句
      string[] values = { "linq学习","linq基本语句","from子句","单个from子句"};
      var value = from v in values
            where v.indexof("linq") > -1
            select new { v, v.length };
      foreach (var n in value)
      {
        console.writeline("{0},{1}",n.v,n.length );
      }
      console.readkey(false);
      //2使用linq查询arraylist
      arraylist glist = new arraylist();
      glist.add(new gustinfo { name="debuglzq", age=26, tel="88888888"});
      glist.add(new gustinfo { name="博客园",age=6, tel ="666666"});
      glist.add(new gustinfo { name = "m&msoft", age =9, tel = "55555" });
 
      var query = from gustinfo gust in glist
            where gust.age > 9
            select gust;//范围变量gust制定了数据类型
      foreach (gustinfo g in query)
      {
        console.writeline("{0} 年龄:{1} 电话:{2}",g.name,g.age,g.tel );
      }
      console.readkey(false);
      //3复合from子句
      list<gustinfo2> glist2 = new list<gustinfo2>()
      {
        new gustinfo2{ name="debuglzq",age=26,teltable=new list<string>(){"8888888","138******"}},
        new gustinfo2{ name="博客园",age=6,teltable =new list<string>(){"666666","138******"}},
        new gustinfo2{ name="m&msoft",age=9,teltable=new list<string>(){"55555","138******"}}
      };
 
      //gust、tel都是查询变量,作用域为当前查询语句！！！
      var query2 = from gust in glist2
             from tel in gust.teltable
             where tel.indexof("5555") > -1
             select gust;
      foreach (var g in query2)
      {
        console.writeline("{0} 年龄{1}",g.name,g.age );
        foreach (var t in g.teltable)
        {
          console.writeline("电话：{0}",t);
        }
      }
 
      console.readkey(false);
 
      //4多个from子句
      var query3 = from gustinfo gust in glist
             where gust.age > 6
             from gustinfo2 gust2 in glist2
             where gust2.age> 9
             select new { gust, gust2 };//查询结果定制
      foreach (var g in query3)
      {
        console.writeline("{0} {1}", g.gust.name, g.gust2.name);
      }
 
      console.readkey(false);
    }
  }
}

程序的运行结果如下：

C#使用LINQ查询表达式的基本子句总结

程序中列举了from子句的用法示例，注意复合from子句和多个from子句的书写，同时需要理解范围变量和数据源变量这两个概念。

 2.where子句
where子句，它是linq表达式的元素筛选机制，除了开始和结束的位置，它几乎可以出现在linq表达式的任意位置上。

在一个linq表达式中，可以有where子句，也可以没有；可以有一个，也可以有多个；多个where子句之间的逻辑关系相当于逻辑“与”，每个where子句可以包含1个或多个bool逻辑表达式，这些条件成为谓词，谓词逻辑之间用的是“&&”“||”等而不是sql中的and 、or。

?
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
using system;
using system.collections.generic;
using system.linq;
using system.text;
 
namespace linq_where
{
  /// <summary>
  /// linq where子句
  /// </summary>
  class program
  {
    static void main(string[] args)
    {
      //1常见的where语句
      list<gustinfo> glist = new list<gustinfo>()
      {
        new gustinfo(){ name="debuglzq", age=26,tel="88888888"},
        new gustinfo(){ name="cnblogs",age=6,tel="666666"},
        new gustinfo(){ name="m&msoft",age=9,tel="55555"}
      };
 
      var query = from gust in glist
            where (gust.name.length > 7 || gust.name.substring(0, 1) == "m") && gust.age > 9
            select new { gust.name, gust.age };
      foreach (var g in query)
      {
        console.writeline("{0},{1}", g.name, g.age);
      }
 
      console.readkey(false);
 
      //2.在where子句中使用自定义函数
      var query2 = from gustinfo gust in glist
             where gust.name.length > 5
             && check(gust.name)
             select gust;
      foreach (var g in query2)
      {
        console.writeline("{0},{1},{2}", g.name, g.age, g.tel);
      }
      console.readkey(false);
 
      //3.动态谓词的筛选
      //定义动态谓词数组,在实际开发中可以动态获得
      string[] names = { "sb","xxx","***","@@@","一些敏感词"};
 
      var query3 = from gustinfo guest in glist
             where !names.contains(guest.name)
             select guest;
 
      foreach (var q in query3)
      {
        console.writeline("{0} 年龄：{1},电话：{2}",q.name,q.age,q.tel );
      }
      console.readkey(false);
    }
 
    //自定义函数
    static bool check(string name)
    {
      if (name.substring(0, 1) == "n")
        return false;
      return true;
    }
  }
}

需要注意一些常用的where子句的写法。程序的运行结果如下：

C#使用LINQ查询表达式的基本子句总结

3.select子句
在select子句上可以非常灵活的处理查询到的元素，然后再把结果返回。

?
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
using system;
using system.collections.generic;
using system.linq;
using system.text;
 
namespace linq_select
{
  /// <summary>
  /// linq select
  /// 在select子句上，可以非常灵活的处理查询到的元素，然后再把结果返回
  /// </summary>
  class mygustinfo
  {
    public string name { get; set; }
    public int age { get; set; }
  }
  class program
  {
    static void main(string[] args)
    {
      list<gustinfo> glist = new list<gustinfo>()
      {
        new gustinfo(){ name="debuglzq", age=25, tel="88888888"},
         new gustinfo(){ name="cnblogs", age=6, tel="666666"},
         new gustinfo(){ name="m&m", age=9, tel="55555"}
      };
      var query = from gust in glist
            where gust.age >= 9 && gust.age <= 30
            select gust.name.replace("&", "mm");//select子句灵活应用
      var query2 = from gust in glist
             where gust.age >= 9 && gust.age <= 30
             select myproc(gust.name);
      var query3 = from gust in glist
             where gust.age >= 9 && gust.age <= 30
             select new { gust.name,gust.age};
 
      var query4 = from gust in glist
             where gust.age >= 9 && gust.age <= 30
             select new mygustinfo { name=gust.name+"my", age=gust.age+1};//对查询结果进行投影
 
      foreach (var v in query)
      {
        console.writeline(v);
      }
      foreach (var v in query2)
      {
        console.writeline(v);
      }
      foreach (var v in query3)
      {
        console.writeline(v.name+v.age );
      }
      foreach (var v in query4)
      {
        console.writeline(v.name+v.age );
      }
 
      console.readkey(false);
    }
    static string myproc(string s)
    {
      return s + "better";
    }
  }
}

程序的运行结果如下：

C#使用LINQ查询表达式的基本子句总结

 4.group子句
 根据语法的规定，linq表达式必须以from子句开头，以select或group子句结束，所以除了使用select来返回结果外，也可以使用group子句来返回元素分组后的结果。

group子句返回的是一个基于igrouping<tkey,telement>泛型接口的对象序列。

语法和sql的group有点区别，不注意的话可能会写错。

?
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
52
53
54
55
using system;
using system.collections.generic;
using system.linq;
using system.text;
 
namespace linq_group
{
  /// <summary>
  /// linq group子句
  /// </summary>
  class program
  {
    static void main(string[] args)
    {
      list<gustinfo> glist = new list<gustinfo>()
      {
        new gustinfo(){ name="debuglzq",age=26,tel="187********"},
        new gustinfo(){ name="sarah",age=25,tel="159********"},
        new gustinfo(){ name="jerry",age=35,tel="135********"},
        new gustinfo(){ name="m&m",age=16,tel="136********"},
        new gustinfo(){ name="debugman",age=26,tel="136********"},
        new gustinfo(){ name="jerry&tom",age=19,tel="136********"},
      };
 
      var query = from guest in glist
            group guest by guest.name.substring(0, 1);//分组键key是string类型
 
      //遍历键值和键值所属元素
      foreach (igrouping<string, gustinfo> guestgroup in query)
      {
        console.writeline("分组键：{0}",guestgroup.key );
        foreach (var g in guestgroup)
        {
          console.writeline("{0} 年龄：{1} 电话：{2}",g.name,g.age,g.tel );
        }
      }
      console.readkey(false);
 
      console.writeline("-----------------------------------");
 
      var query2 = from guest in glist
             group guest by guest.age > 20;//分组键key是bool类型表达式的结果
 
      foreach (igrouping<bool, gustinfo> guestgroup in query2)
      {
        console.writeline("年龄是否大于20 分组键：{0}", guestgroup.key);
        foreach (var g in guestgroup)
        {
          console.writeline("{0} 年龄：{1} 电话：{2}", g.name, g.age, g.tel);
        }
      }
      console.readkey(false);
    }
  }
}

程序的运行结果如下：

C#使用LINQ查询表达式的基本子句总结

5.into子句
 into子句作为一个临时标识符，用于group、select、join子句中充当其结果的引用。

?
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
52
53
54
55
56
57
58
59
60
using system;
using system.collections.generic;
using system.linq;
using system.text;
 
namespace linq_into
{
  /// <summary>
  /// linq group
  /// </summary>
  class program
  {
    static void main(string[] args)
    {
      list<gustinfo> glist = new list<gustinfo>()
      {
        new gustinfo(){ name="debuglzq",age=26,tel="187********"},
        new gustinfo(){ name="sarah",age=25,tel="159********"},
        new gustinfo(){ name="jerry",age=35,tel="135********"},
        new gustinfo(){ name="m&m",age=16,tel="136********"},
        new gustinfo(){ name="debugman",age=26,tel="136********"},
        new gustinfo(){ name="jerry&tom",age=19,tel="136********"},
      };
 
      //1.into用于group子句
      var query = from guest in glist
            group guest by guest.name.substring(0, 1) into grguest
            orderby grguest.key descending
            select grguest;
 
      var query2 = from guest in glist
            group guest by guest.name.substring(0, 1) into grguest
            orderby grguest.key ascending
            select grguest;
 
      //2.select 子句中的into子句
      var query3 = from guest in glist
             select new { newname = guest.name, newage = guest.age } into newguest
             orderby newguest.newage
             select newguest;
 
      foreach (var guestgroup in query)
      {
        console.writeline("分组键：{0}",guestgroup.key );
        foreach (var g in guestgroup)
        {
          console.writeline("{0} 电话:{1}",g.name,g.tel );
        }
      }
      console.readkey(false);
 
      foreach (var newg in query3)
      {
        console.writeline("{0} 年龄：{1}",newg.newname,newg.newage );
      }
 
      console.readkey(false);
    }
  }
}

程序运行结果如下：

C#使用LINQ查询表达式的基本子句总结

6.orderby子句、thenby子句
 linq可以按照元素的一个或多个属性对元素进行排序。

?
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
52
53
54
55
56
57
58
59
using system;
using system.collections.generic;
using system.linq;
using system.text;
 
namespace linq_orderby
{
  class program
  {
    /// <summary>
    /// linq orderby (ascending descending)
    /// </summary>
    /// <param name="args"></param>
    static void main(string[] args)
    {
      list<gustinfo> glist = new list<gustinfo>()
      {
        new gustinfo(){ name="debuglzq",age=26,tel="187********"},
        new gustinfo(){ name="sarah",age=25,tel="159********"},
        new gustinfo(){ name="jerry",age=35,tel="135********"},
        new gustinfo(){ name="m&m",age=16,tel="136********"},
        new gustinfo(){ name="debugman",age=26,tel="136********"},
        new gustinfo(){ name="jerry&tom",age=19,tel="136********"},
      };
 
      //按照年龄排序
      var query = from guest in glist
            orderby guest.age
            select guest;
      var query1 = from guest in glist
             orderby guest.age ascending
             select guest;
      var query2 = from guest in glist
             orderby guest.age descending
             select guest;
      //按照年龄进行排序，按照名字字数进行次要排序
      var query3 = from guest in glist
            orderby guest.age, guest.name.length
            select guest;
      var query4 = from guest in glist
             orderby guest.age descending , guest.name.length ascending
             select guest;
      var query5 = from guest in glist
             orderby guest.age, guest.name.length,guest.tel
             select guest;
 
      foreach (var guest in query2)
      {
        console.writeline("{0} 年龄：{1} 电话：{2}",guest.name,guest.age,guest.tel );
      }
      console.readkey(false);
      foreach (var guest in query4)
      {
        console.writeline("{0} 年龄：{1} 电话：{2}", guest.name, guest.age, guest.tel);
      }
      console.readkey(false);
    }
  }
}

程序运行结果如下：

C#使用LINQ查询表达式的基本子句总结

7.let子句
let子句用于在linq表达式中存储子表达式的计算结果。

?
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
using system;
using system.collections.generic;
using system.linq;
using system.text;
 
namespace linq_let
{
  /// <summary>
  /// linq let用来存子储表达式的计算结果
  /// </summary>
  class program
  {
    static void main(string[] args)
    {
      list<gustinfo> glist = new list<gustinfo>()
      {
        new gustinfo(){ name="debuglzq",age=26,tel="187********"},
        new gustinfo(){ name="sarah",age=25,tel="159********"},
        new gustinfo(){ name="jerry",age=35,tel="135********"},
        new gustinfo(){ name="m&m",age=16,tel="136********"},
        new gustinfo(){ name="debugman",age=26,tel="136********"},
        new gustinfo(){ name="jerry&tom",age=19,tel="136********"},
      };
 
      //使用let子句创建范围变量g，并通过g构建查询表达式
      var query = from guest in glist
            let g = guest.name.substring(0, 1)
            where g == "d" || g == "j"
            select guest;
      //也可以不使用let，上面的语句等效于下
      var query2 = from guest in glist
             where guest.name.substring(0, 1) == "d" || guest.name.substring(0, 1) == "j"
             select guest;
 
      foreach (var g in query)
      {
        console.writeline("{0} 年龄：{1} 电话：{2}",g.name,g.age,g.tel );
      }
      console.readkey(false);
      console.writeline("不使用let，等效的语句结果");
      foreach (var g in query2)
      {
        console.writeline("{0} 年龄：{1} 电话：{2}", g.name, g.age, g.tel);
      }
      console.readkey(false);
    }
  }
}

程序的运行结果如下：

C#使用LINQ查询表达式的基本子句总结

8.join子句
如果一个数据源中元素的某个属性可以跟另外一个数据源的中元素的某个属性进行相等比较，那么这两个数据源可以用join子句进行关联。

join子句使用equals关键字进行相等比较，而不是常用的双等号。

?
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
using system;
using system.collections.generic;
using system.linq;
using system.text;
 
namespace linq_join
{
  class program
  {
    static void main(string[] args)
    {
      //定义两个数据源
      list<gustinfo> glist = new list<gustinfo>()
      {
        new gustinfo(){ name="debuglzq",age=26,tel="187********"},
        new gustinfo(){ name="sarah",age=25,tel="159********"},
        new gustinfo(){ name="jerry",age=35,tel="135********"},
        new gustinfo(){ name="m&m",age=16,tel="136********"},
        new gustinfo(){ name="debugman",age=26,tel="136********"},
        new gustinfo(){ name="jerry&tom",age=19,tel="136********"},
      };
 
      list<guesttitle> titlelist = new list<guesttitle>()
      {
        new guesttitle(){name="debuglzq",title="soft engineer"},
        new guesttitle(){name="debuglzq",title="team leader"},
        new guesttitle(){name="sarah",title="test engineer"},
        new guesttitle(){name="jerry",title="head master"}
      };
      //1.根据姓名进行内连接
      var query = from guest in glist
            join title in titlelist on guest.name equals title.name
            select new { name=guest.name ,title=title.title,age=guest.age };
 
      foreach (var g in query)
      {
        console.writeline("{0} {1} 年龄：{2}",g.name,g.title ,g.age );
      }
      console.readkey(false);
 
      //前面的多个from实现相同的作用:与内连接区别在于：这个中间的操作是叉乘获得笛卡尔积
      var query2=from guest in glist
            from title in titlelist
            where guest.name==title.name
            select new { name = guest.name, src="/uploads/allimg/211115/1435555948-7.jpg" />

以上就是linq的基本子句的常用用法，文字不是很多，因为代码中都有详细的注释说明。

1 本网站名称：米米素材网
2 本站永久网址：https://www.mimisucai.cn
3 本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权进行删除处理。
4 本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
5 本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
6 本站资源大多存储在云盘，如发现链接失效，请联系我们我们会第一时间更新。

相关阅读

发表评论

说点什么吧
  • 全部评论（0）
    还没有评论，快来抢沙发吧！
取消
微信二维码
微信二维码
支付宝二维码
TAGS标签 充值帮助(？) 广告投放 网站地图 关于我们 用户协议 版权声明

Copyright2015-2023米米素材网收集了国内优质的素材网站大全. 涵盖PPT模板、海报、PSD素材、Word模板、元素、Excel表格、字体、CAD、广告设计、网站源码资源以及编程代码学习，为建站开发人员提供优质的服务。

本站采用创作共用版权. 基于DedeCMS搭建. 安全运行天 许可协议，转载或复制请注明出处

苏ICP备2022017718号苏ICP备2022017718号苏公网安备 32058502010603号苏公网安备 32058502010603号

微信公众号