zoukankan      html  css  js  c++  java
  • Linq

    1. 方法:Where,Max,Select,Sum,Any,Average,All,Concat等

    .查询操作符

        (1)源起

          .net的设计者在类库中定义了一系列的扩展方法

          来方便用户操作集合对象

          这些扩展方法构成了LINQ的查询操作符

        (2)使用

          这一系列的扩展方法,比如:

          Where,Max,Select,Sum,Any,Average,All,Concat等

          都是针对IEnumerable的对象进行扩展的

          也就是说,只要实现了IEnumerable接口,就可以使用这些扩展方法

          来看看这段代码:      

                List<int> arr = new List<int>() { 1, 2, 3, 4, 5, 6, 7 };            var result = arr.Where(a => { return a > 3; }).Sum();
                Console.WriteLine(result);
                Console.ReadKey();

          这段代码中,用到了两个扩展方法。

          <1>

            Where扩展方法,需要传入一个Func<int,bool>类型的泛型委托

            这个泛型委托,需要一个int类型的输入参数和一个布尔类型的返回值

            我们直接把a => { return a > 3; }这个lambda表达式传递给了Where方法

            a就是int类型的输入参数,返回a是否大于3的结果。

          <2>

            Sum扩展方法计算了Where扩展方法返回的集合的和。

        (3)好处

          上面的代码中

          arr.Where(a => { return a > 3; }).Sum();

          这一句完全可以写成如下代码:

          (from v in arr where v > 3 select v).Sum();

          而且两句代码的执行细节是完全一样的

          大家可以看到,第二句代码更符合语义,更容易读懂

          第二句代码中的where,就是我们要说的查询操作符。

        (4)标准查询操作符说明

          <1>过滤

            Where

            用法:arr.Where(a => { return a > 3; })

            说明:找到集合中满足指定条件的元素

            OfType

            用法:arr.OfType<int>()

            说明:根据指定类型,筛选集合中的元素

          <2>投影

            Select

            用法:arr.Select<int, string>(a => a.ToString());

            说明:将集合中的每个元素投影的新集合中。上例中:新集合是一个IEnumerable<String>的集合

            SelectMany

            用法:arr.SelectMany<int, string>(a => { return new List<string>() { "a", a.ToString() }; });

            说明:将序列的每个元素投影到一个序列中,最终把所有的序列合并

          <3>还有很多查询操作符,请翻MSDN,以后有时间我将另起一篇文章把这些操作符写全。      

      2.查询表达式

        (1)源起

          上面我们已经提到,使用查询操作符表示的扩张方法来操作集合

          虽然已经很方便了,但在可读性和代码的语义来考虑,仍有不足

          于是就产生了查询表达式的写法。

          虽然这很像SQL语句,但他们却有着本质的不同。

        (2)用法

          from v in arr where v > 3 select v

          这就是一个非常简单的查询表达式

        (3)说明:

          先看一段伪代码:      

          from [type] id in source
          [join [type] id in source on expr equals expr [into subGroup]]
          [from [type] id in source | let id = expr | where condition]
          [orderby ordering,ordering,ordering...]
          select expr | group expr by key
          [into id query]

          <1>第一行的解释:

            type是可选的,

            id是集合中的一项,

            source是一个集合,

            如果集合中的类型与type指定的类型不同则导致强制转化

          <2>第二行的解释:        

            一个查询表达式中可以有0个或多个join子句,

            这里的source可以不等于第一句中的source

            expr可以是一个表达式

            [into subGroup] subGroup是一个中间变量,

            它继承自IGrouping,代表一个分组,也就是说“一对多”里的“多”

            可以通过这个变量得到这一组包含的对象个数,以及这一组对象的键

            比如:        

    复制代码
            from c in db.Customers
                join o in db.Orders on c.CustomerID
                equals o.CustomerID into orders
                select new
                {
                    c.ContactName,
                    OrderCount = orders.Count()
                };
    复制代码

          <3>第三行的解释:     

            一个查询表达式中可以有1个或多个from子句

            一个查询表达式中可以有0个或多个let子句,let子句可以创建一个临时变量

            比如:        

                from u in users
                 let number = Int32.Parse(u.Username.Substring(u.Username.Length - 1))
                 where u.ID < 9 && number % 2 == 0
                 select u

            一个查询表达式中可以有0个或多个where子句,where子句可以指定查询条件

          <4>第四行的解释:

            一个查询表达式可以有0个或多个排序方式

            每个排序方式以逗号分割

          <5>第五行的解释:

            一个查询表达式必须以select或者group by结束

            select后跟要检索的内容

            group by 是对检索的内容进行分组

            比如:        

                from p in db.Products  
                group p by p.CategoryID into g  
                select new {  g.Key, NumProducts = g.Count()};

          <6>第六行的解释:

            最后一个into子句起到的作用是

            将前面语句的结果作为后面语句操作的数据源

            比如:        

    复制代码
                from p in db.Employees
                 select new
                 {
                     LastName = p.LastName,
                     TitleOfCourtesy = p.TitleOfCourtesy
                 } into EmployeesList
                 orderby EmployeesList.TitleOfCourtesy ascending
                 select EmployeesList;

                 List<int> linq = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };

                var result = linq.Where(a => { return a <= 3; }).Sum();     //6

                var result2 = linq.Where(b => { return b > 8; }).Max();     //9

                var result3 = (from v in linq where v >= 8 select v).Sum(); //17

                var result4 = linq.OfType<int>().Sum();

                var result5 = linq.Select<int, string>(a => a.ToString());

                var result6 = linq.SelectMany<int, string>(a => { return new List<string>() { "a",a.ToString() }; });

  • 相关阅读:
    005 ES的文档一些控制
    004 REST风格中在ES中的约定
    003 接触elasticsearch的Restful Api【快速入门】
    002 elasticsearch中的一些概念
    001 centos7下安装kibana
    000 centos7下安装elasticsearch7的单节点安装
    006 DOM节点操作与元素的创建
    006 认识BeanNameAware
    005 Spring和SpringBoot中的@Component 和@ComponentScan注解
    004 JpaRepository,CrudRepository,PagingAndSortingRepository的区别
  • 原文地址:https://www.cnblogs.com/BeeSnow/p/7922733.html
Copyright © 2011-2022 走看看