LINQ基础

以下为《C#图解教程》读书笔记

LINQ是

直接嵌入C#的强类型查询语言

与LINQ相关的特性:

隐式类型的本地变量:使用var

对象/集合初始化语法:对象初始化语句/对象初始化器/对象初始化表

Lamdba表达式:lambda表达式

扩展方法//写一个静态类给已知类添加方法,使用时看起来这个类里面本来就有这个方法.

匿名类型:匿名类型

 

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包含的是真实的整数值,它只能通过真实运行查询才能得到

 

查询表达式结构

注意事项:

• 按照一定的顺序出现
• from子句和select...group子句是必须的
• 其他语句是可选的
• select子句在表达式最后

 

from子句

from指定了查询的数据集合,每一个LINQ查询都要以from开始

语法:

frome type Item in Items

//type 是可选的,因为编译器会帮你推断

与foreach的区别

foreach指定从第一个开始到结束,from之规定集合的每一项都要访问

foreach遇到代码就执行主体,from 只是创建可执行查询的后台代码对象

 

jion 联结:

使用联结来结合多个集合的数据

联结操作接受两个集合然后创建一个临时的对象集合,每一个对象包含原始集合中的所有字段.

语法:

自我理解:

联结就是把join前的集合与jion后的集合合成一个集合,当然要设置一些选择条件

还是看代码说话

 

书上:

 

代码示例:

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值

阴影为联结结果

 

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="自动写了
        }
    }

 

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

结果:

 

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

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

   


 

 

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核心程序集