LINQ入门

LINQ入门

推荐教程

• LINQ之路系列博客导航
• Part 1 - What is LINQ系列教程

LINQ是.NET Framework 3.5的新特性，其全称是 Language Integrated Query，即语言集成查询，是指将查询功能和语言结合起来。它允许我们以使用SQL查询数据库的方式来查询数据集合。使用LINQ，可以从数据库、程序的对象的集合以及XML文档中查询数据

预备知识

匿名类型

创建匿名类型的变量，没有类名和构造函数。如下：

            var student = new { Name = "John Snow", Age = 19, Major = "History" };
            Console.WriteLine("{0}, Age{1}, Major:{2}", student.Name, student.Age, student.Major);

注意事项：

1.匿名类型只能和局部变量配合使用，不能用于类成员
2.由于匿名类型没有名字，须使用var关键字作为变量类型
3.匿名类型的属性是只读的，不能设置匿名类型对象的属性

LINQ

LINQ查询使用两种形式的语法：查询语法和方法语法

• 方法语法(method syntax)使用标准的方法调用
• 查询语法(query syntax)看上去与SQL语句相似，使用查询表达式书写

LINQ查询可以返回两种类型的结果：

• 枚举，满足查询参数的项列表

  int[] numbers = { 2, 12, 5, 15, 20, 17, 88, 100};
  IEnumerable<int> lowNums = from n in numbers where n < 10 select n;

• 标量，单一值

  int numsCount = (from n in numbers where n < 20 select n).Count();

注意lowNums 查询变量不会包含查询结果，相反，编译器会创建能够执行这个查询的代码。查询变量numsCount包含的是真实的整数值

区别：

• 如果查询表达式返回枚举 ，查询一直到处理枚举时才会执行
• 如果枚举被处理多次，查询就会执行多次
• 如果在进行遍历之后，查询执行之前数据有改动，则查询会使用新的数据
• 如果查询表达式返回标量，查询立即执行，并且把结果保存在查询变量中

查询表达式的结构

from子句和select…group子句是必须的，其它子句是可选的。在LINQ查询表达式中， select子句在表达式最后

from子句

from子句指定了要作为数据源使用的数据集合。它还引入了迭代变量。语法如下：

from Type Item in Items

• Type表示集合中元素的类型，是可选的
• Item是迭代变量的名字
• Items是要查询集合的名字。集合必须是可枚举的

如下：

            int[] arr1 = { 10, 11, 12, 13 };
            var query = from item in arr1 where item < 13 select item;
            foreach (var item in query)
            {
                Console.Write("{0}, ", item);
            }

我们看到查询表达式从必需的from子句开始，后面跟的是查询的主体。主体本身可以从任何数量的其它from子句开始，每一个from子句都指定了一个额外的源数据集合并引入了要在之后运算的迭代变量，所有的from子句的语法和含义都是一样的

            var groupA = new[] { 3, 4, 5, 6 };
            var groupB = new[] { 6, 7, 8, 9 };
            var someInts = from a in groupA
                           from b in groupB
                           where a > 4 && b <= 8
                           select new { a, b, sum = a + b };
            foreach (var a in someInts)
            {
                Console.WriteLine(a);
            }

其输出结果为：

{ a = 5, b = 6, sum = 11 }
{ a = 5, b = 7, sum = 12 }
{ a = 5, b = 8, sum = 13 }
{ a = 6, b = 6, sum = 12 }
{ a = 6, b = 7, sum = 13 }
{ a = 6, b = 8, sum = 14 }

let子句

let子句接受一个表达式的元素并把它赋值给一个需要在其他运算中使用的标识符

            someInts = from a in groupA
                       from b in groupB
                       let sum = a+b
                       where sum == 12
                       select new { a, b, sum };
            foreach (var a in someInts)
            {
                Console.WriteLine(a);
            }

其输出结果为：

{ a = 3, b = 9, sum = 12 }
{ a = 4, b = 8, sum = 12 }
{ a = 5, b = 7, sum = 12 }
{ a = 6, b = 6, sum = 12 }

where子句

where子句根据之后的运算来去除不符合条件的项。
只要在from…let…where部分中，查询表达式可以有任意多个where子句

            someInts = from a in groupA
                       from b in groupB
                       let sum = a + b
                       where sum >= 11
                       where a == 4
                       select new { a, b, sum };

join子句

LINQ中的join子句和SQL中的JOIN子句类似。语法如下：

join Identifier in Collection2 on Field1 equals Field2

注意必须使用上下文关键字equals来比较字段

如下的例子：

 public class Join
    {
        public class Student
        {
            public int StID;
            public string LastName;
        }

        public class CourseStudent
        {
            public string CourseName;
            public int StID;
        }

        static Student[] students = new Student[] {
            new Student{StID=1, LastName="Carson"},
            new Student{StID=2, LastName="Klassen"},
            new Student{StID=3, LastName="Fleming"},
        };

        static CourseStudent[] studentsInCourses = new CourseStudent[] 
        {
            new CourseStudent{CourseName="Art", StID=1},
            new CourseStudent{CourseName="Art", StID=2},
            new CourseStudent{CourseName="History", StID=1},
            new CourseStudent{CourseName="History", StID=3},
            new CourseStudent{CourseName="Physics", StID=3},
        };

        static void Main()
        {
            //查找所有选择了历史课的学生的姓氏
            var query = from s in students
                        join c in studentsInCourses on s.StID equals c.StID
                        where c.CourseName == "History"
                        select s.LastName;

            foreach (var q in query)
            {
                Console.WriteLine("Student taking History: {0}", q);
            }

        }
    }

orderby子句

orderby子句接受一个表达式并根据表达式按顺序返回结果项。
orderby子句默认排序是升序。可以使用ascending和descending关键字显示地设置元素的排序为升序或降序

如下的例子：

            var stus = new[] {
                new {LName="Jones", FName="Mary", Age=19, Major="History"},
                new {LName="Smith", FName="Bob", Age=20, Major="CompSci"},
                new {LName="Fleming", FName="Carol", Age=21, Major="History"},
            };

            var queryStus = from student in stus
                            orderby student.Age
                            select student;
            foreach (var s in queryStus)
            {
                Console.WriteLine("{0}, {1}: {2}-{3}", s.LName, s.FName, s.Age, s.Major);
            }

其输出结果为：

Jones, Mary: 19-History
Smith, Bob: 20-CompSci
Fleming, Carol: 21-History

group子句

group子句把select的对象根据一些标准进行分组。

• 如果项包含在查询结果中，它们就可以根据某个字段的值进行分组。作为分组依据的属性叫做键（key）
• group子句返回的不是原始数据源中项的枚举，而是返回可以枚举已经形成的项的分组的可枚举类型

如下的例子：

            var stus = new[] {
                new {LName="Jones", FName="Mary", Age=19, Major="History"},
                new {LName="Smith", FName="Bob", Age=20, Major="CompSci"},
                new {LName="Fleming", FName="Carol", Age=21, Major="History"},
            };
            var groupQuery = from student in stus
                             group student by student.Major;

            foreach (var s in groupQuery)
            {
                Console.WriteLine("{0}", s.Key);
                foreach (var t in s)
                {
                    Console.WriteLine("      {0}, {1}", t.LName, t.FName);
                }
            }

其输出结果为：

History
      Jones, Mary
      Fleming, Carol
CompSci
      Smith, Bob