LINQ基础

时间：2023-03-09 18:22:33
LINQ基础
以下为《C#图解教程》读书笔记

LINQ是

直接嵌入C#的强类型查询语言
与LINQ相关的特性:
隐式类型的本地变量:使用var
Lamdba表达式:lambda表达式
扩展方法//写一个静态类给已知类添加方法,使用时看起来这个类里面本来就有这个方法.
匿名类型:匿名类型
LiNQ可应用方面:
LINQ基础
LINQ语法
有两种形式语法,两着性能上没区别:
举例:
假设已定义了一个数组numbers
方法语法:
var A=numbers.Where(x=>x<20);
//这里用到了Lambda
查询语法:
var A=from n in numbers
    where n<20
    select n;
//这里返回了一个对象,这个对象能形容具体的查询步骤,这里并没有进行查询动作
查询变量:
查询结果一般为一组可枚举的数据或者一个叫做标量的单一值
一组可枚举数据:
上面的查询语法的A不包含查询结果,相反,编译器会创建能够执行这个查询的代码
标量:
 int count=(from n in numbers where n<20 select n).Count();
//这里是查询语句与方法语句的结合
count包含的是真实的整数值,它只能通过真实运行查询才能得到
LINQ基础
查询表达式结构
注意事项:
  • 按照一定的顺序出现
  • from子句和select...group子句是必须的
  • 其他语句是可选的
  • select子句在表达式最后

LINQ基础

from子句
from指定了查询的数据集合,每一个LINQ查询都要以from开始
语法:
frome type Item in Items
//type 是可选的,因为编译器会帮你推断
与foreach的区别
foreach指定从第一个开始到结束,from之规定集合的每一项都要访问
foreach遇到代码就执行主体,from 只是创建可执行查询的后台代码对象
jion 联结:
使用联结来结合多个集合的数据
联结操作接受两个集合然后创建一个临时的对象集合,每一个对象包含原始集合中的所有字段.
语法:
自我理解:
联结就是把join前的集合与jion后的集合合成一个集合,当然要设置一些选择条件
还是看代码说话
书上:
LINQ基础
代码示例:
  1.  //这个代码声明了两个类
 //第一个代表学生,每个学生都有学生的名字和ID
 //第二个代表课程,每个课程类都有学生的ID和课程的名字
 class Program
 {
     public class Student
     {
         public int StID;
         public string LastName;
     }
     public class CourseStudent
     {
         public string CourseName;
         public int StID;
     }
     //在全局中创建学生类与课程类
     //课程类与学生类中有一样的ID
     static Student[] students =newStudent[]{
         ,LastName="Carson"},
         ,LastName="Klassen"},
         ,LastName="Fleming"},
     };
     static CourseStudent[] studentsInCourses =new CourseStuden t[]{
         },
         },
         },
         },
         },
     };
     static void Main()
     {
         var query =from s in students//开始查询,在一个集合内查询
                     join c in studentsInCourses on s.StID equals c.StID
                     //而这个集合是,由两个集合的部分组成,上面的意思是:
                     //定义students的迭代变量a
                     //定义studentsInCourses迭代变量c
                     //联结这连个集合中的成员,并生成新的一个集合
                     //联结结果是:把两个集合成员具有相同StID的拿出来组成一个新的集合
                     where c.CourseName=="History"
                     //找出新集合中CourseName== "History"的成员
                     select s.LastName;
                     //把这些成员的LastName返回
         foreach(var q in query)
         Console.WriteLine("Student taking History: {0}", q);
         Console.ReadKey();
     }
 }
联结过程图例:
左students右CourseName
每次拿去students的元素更CourseName比较
比较两者的StID值
阴影为联结结果
LINQ基础
from... let.... where子句
from语句
每一个from语句都引入一个新的数据源
  1.  class Program
 {
     static void Main()
     {
         ,,,};
         ,,,};
         var someInts =from a in groupA//必须的第一个from语句
                     from b in groupB//主句中的from语句
                     select new{ a, b, sum=a+b };//创建一个匿名类型
         foreach(var a in someInts )
         Console.WriteLine( a );//很神奇,"a=","b="自动写了
     }
 }
LINQ基础
let子句
接受一个表达式式的运算并且把它复制给一个需要在其他运算中使用的标示符
  1.  class Program
 {
     static void Main()
     {
         ,,,};
         ,,,};
         var someInts =from a in groupA
                     from b in groupB
                     let sum = a + b

                     select new{ a, b, sum };
         foreach(var a in someInts )
         Console.WriteLine( a );
     }
 }
结果:
LINQ基础
where子句
where子句根据之后的运算来去除不符合指点条件的项
注意:
只要在from...let...where部分中,查询表达式可以是任意个
  1.  static void Main()
 {
     ,,};
     ,,,};
     var someInts =from int a in groupA
                 from int b in groupB
                 let sum = a + b

                 select new{ a, b, sum };
     foreach(var a in someInts )
     Console.WriteLine( a );
 }
LINQ基础
orderby
orderby子句接受一个表达式并根据表达式按顺序返回结果项
表达式通常是字段,但不一定是数值型,也可以是字符串
表达式后面能跟(ascending或descending)//可选的,分别用来设置升序或者降序,默认升序
  1.  classProgram
 {
     static void Main()
     {
         var students =new[]
         {
             ,Major="History"},
             ,Major="CompSci"},
             ,Major="History"}
         };
         var query =from student in students
         orderby student.Age ascending//降序descending
         select student;
         foreach(var s in query)
         {
             Console.WriteLine("{0}, {1}: {2} - {3}",
             s.LName, s.FName, s.Age, s.Major);
         }
         Console.ReadKey();
     }
 }
select...group子句
由两个部分组成select...group:
select子句和group...by子句
select子句
select子句指定了所选对象的哪一个部分被选择这个部分可以是:
整个数据项
数据项的一个字段
数据项的几个字段组成的新对象//匿名类型
group...by
group...by子句是可选的,用来指定选择项是如何被分组.
group语句吧select的对象根据一些标准进行分组,
如果仅仅写了from语句和goup by语句,返回的是IEnumerable<IGrouping<键,值>>
  1.  classProgram
 {
     static void Main()
     {
         var students =new[]
         {
             ,Major="History"},
             ,Major="CompSci"},
             ,Major="History"}
         };
         var query =from student in students
                    group student by student.Major;
                    //query是返回的是IEnumerable<IGrouping<键,值>>,所以下面不能直接打印
         foreach(var s in query )
         {
             Console.WriteLine("{0}", s.Key);//key是分组键
             foreach(var t in s )
             Console.WriteLine(" {0}, {1}", t.LName, t.FName);
         }
     }
 }


LINQ基础
into子句
插叙延续子句可以接受查询的一部分结果并赋予新的名字,把它用于其它的查询
  1.  classProgram
 {
     static void Main()
     {
         ,,,};
         ,,,};
         var someInts =from a in groupA
                         join b in groupB on a equals b
                         into groupAandB
                         from c in groupAandB
                         //选中groupA与groupB相同的部分把这部分取名为grupAandB
                         select c;
         foreach(var a in someInts )
         Console.Write("{0} ", a );
     }
 }
LINQ基础
Linq核心程序集
LINQ基础

相关文章