C#4.0图解教程 第21章 介绍LINQ

21.1 什么是LINQ

static void Main(string[] args)
 {
int[] numbers = { 2, 12, 5, 15 };
IEnumerable<int> lowNums = from n in numbers
where n < 10
select n;
foreach (var lowNum in lowNums)
 {
Console.Write("{0}, ",lowNum);
 }
}

结果：2，5，

21.2 LINQ提供程序

匿名类型

创建对象表达式时初始化新类实例的字段和属性，这种形式的创建表达式由三部分组成：new关键字、类名或构造函数以及对象初始化器。对象初始化器在一组大括号内包含了逗号分隔的成员初始化列表。

创建匿名类型的变量使用相同形式，但没有类名和构造方法。

匿名类型实例：

 static void Main(string[] args)
{
var student = new
{
LName = "Jones",
FName = "Mary",
Age = 19,
Major = "History"
};
Console.WriteLine(
"{0}{1},Age {2},Major:{3}",
student.FName,
student.LName,
student.Age,
student.Major
);
}

21.3 查询语法和方法语法

查询语法：是声明形式，像SQL。

方法语法：是命令形式，使用标准方法调用，方法是一组叫做标准查询运算符的方法。

 static void Main(string[] args)
{
int[] numbers = { 2, 5, 28, 31, 17, 16, 42 };
var numsQuery = from n in numbers //查询语法
where n < 20
select n;
var numsMethod = numbers.Where(x => x < 20); //方法语法 
int numsCount = (from n in numbers //两种形式组合
where n < 20
select n).Count();
foreach (var i in numsQuery)
{
Console.Write("{0},", i);
}
Console.WriteLine();
foreach (var i in numsMethod)
{
Console.Write("{0},", i);
}
Console.WriteLine();
Console.WriteLine(numsCount);
}

21.4 查询变量

LINQ返回两种类型的结果——

一个枚举（可枚举的一组数据，不是枚举类型），它列出了满足查询参数的的项列表；

一个叫做标量（scalar）的单一值（某种摘要形式）。

static void Main(string[] args)
 {
int[] arr1 = { 2, 5, 28 };
IEnumerable<int> lowNums = from i in arr1 //返回枚举数
where i < 20
select i;
var numsCount = (from n in arr1
where n < 20
select n).Count(); //返回一个整数
foreach (var lowNum in lowNums)
 {
 Console.Write(lowNum);
 }
 Console.WriteLine();
 Console.WriteLine(numsCount);
//结果：
//25
//2
}

21.5 查询表达式的结构

21.5.1 from 子句

from Type Item in Item

21.5.2 join 子句

join Identifier inColiiection2 on Field1 equals Filed2

示例：

21.5.3 什么是联结

class Program
 {
public class Student
 {
// Declare classes.
public int StID;
public string LastName;
 }

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

// Initialize arrays. 初始化数组
private 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},
 };

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

private static void Main()
 {
// Find the last names of the students taking history.
var query = from s in students
join c in studentsInCourses on s.StID equals c.StID
where c.CourseName == "History"
select s.LastName;
// Display the names of the students taking history.
foreach (var q in query)
Console.WriteLine("Student taking History: {0}", q);
 }
}

结果：

Student taking History:  Carson
Student taking History:  Fleming
请按任意键继续. . .

21.5.4 查询主体中的 from...let...where 片段

1.from

 static void Main()
{
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);
}

 

2.let子句

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

let Identifier(标识符) = Expression(表达式)

static void Main()
 {
var groupA = new[] { 3, 4, 5, 6 };
var groupB = new[] { 6, 7, 8, 9 };
var 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);
}

3.where子句

where BooleamExpression

1.只要在from..let..where部分始终，表达式可以存在多个where子句。

2.一个项目必须满足 where 子句才能避免在之后被过滤。

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

21.5.5 orderby 子句

1.orderby默认为升序。我们可以设置ascending和descending选择升序或降序。

2.可以有任意多个子句，他们必须使用逗号分隔。

static void Main()
 {
var students = new[] // Array of objects of an anonymous type
 {
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 query = from student in students
orderby student.Age descending
select student;
foreach (var s in query)
 {
Console.WriteLine("{0}, {1}: {2} - {3}",
 s.LName, s.FName, s.Age, s.Major);
 }
}

Fleming, Carol:  21 - History
Bob:  20 - CompSci 
Jones, Mary:  19 - History 
请按任意键继续. . .