C# 标准查询表达式

一、标准查询运算符

1、C#提供了标准查询运算符，例如我想选择专利一系列(pantents)中以年份19开头的专利，可以用如下语句：

            IEnumerable<Patent>  pantentWhere = pantents.Where(pantent => 

                                                                pantent.YearOfPublicaton.StartsWith("19"));

当然，此处的语句只是定义了查询，此时pantentWhere并没有内容，后面Lambda表达式指定的查询并没有执行，只有当遍历pantentWhere集合的时候才开始执行这个查询规则，这是C#中标准查询的“推迟执行”

2、投射

专利类包含了 名字  年份  应用号  发明者 等，如果我想将专利类的集合中 每个专利的类型都变为只包含 名字与年份的类型，那么可以使用select做到，代码如下：

1 var pantentSelect = pantents.Select(

2                 pantent => 

3                 { 

4                     return new 

5                     { 

6                         Title = pantent.Title, 

7                         Year = pantent.YearOfPublicaton 

8                     }; 

9                 });

可以看到，Lambda表达式返回了一个包含 名字与年份的类型。而当遍历pantentSelect时，其投射语句执行，它则是有[（姓名，值），（年份，值）]构成的集合。

3、排序

利用标准查询运算符OrderByDescending 与 ThenByDescending 可以完成多条件的排序，代码如下：

1 IEnumerable<Patent> pantentOrder = pantents.OrderByDescending(pantent => 

2                                                           pantent.YearOfPublicaton).ThenByDescending(

3                                                           pantent => pantent.Title);

可以看到，只用了一个OrderBy，它会获取并且只会获取一个成为KeySelector的参数来排序，例如本例中的YearOfPublicaton。如果要继续按照第二个关键字排序，只能用ThenBy，在OrderBy的基础上执行。而连着使用多个OrderBy只会撤销上一个OrderBy，所以要用ThenBy，而不是继续使用OrderBy。

此处仅仅简单的列出几项，因为如果执行比较复杂的查询与投射，将会产生比较繁琐难懂的代码。因此，C# 3.0中引入了标准查询表达式，一种更类似于SQL语言的

二、标准查询表达式

1、简单示例，下段代码完成的功能是检索出不含有*的单词：

 1 class Program

 2     {

 3         static string[] Keywords = { "*a", "*b", "*c", "*d", "*e", "*f", "a", "b", "c", "d", "e", "f", "g", "h", "i"};

 4         static void Main(string[] args)

 5         {

 6             ShowContextualKeyword1();

 7         }

 8         public static void ShowContextualKeyword1()

 9         {

10             IEnumerable<string> selection = from word in Keywords

11                                             where !word.Contains('*')

12                                             select word;

13             foreach (string s in selection)

14             {

15                 Console.WriteLine(" " + s);

16             }

17         }

18     }

值得详细说一下的是类型推断：select投射回的是word的集合，word的类型是from后面的那个word，从Keywords推断得到。Keywords是一个string的集合，所以word是string类型，因此select投射到的是IEnumerable<string>

 2、改变返回类型。

select不仅可以返回原始类型，也可以返回指定的类型，我个人总结的是 他会返回select后面的变量的集合类型。

如下代码，返回的不是fileName的集合，而是FileInfo的集合：

1   public static void List1(string rootDirectory, string searchPattern)

2         {

3             IEnumerable<FileInfo> files = from fileName in Directory.GetFiles(rootDirectory, searchPattern)

4                                           select new FileInfo(fileName);

5             foreach (FileInfo file in files)

6             {

7                 Console.WriteLine(".{0}({1})",file.Name,file.LastWriteTime);

8             }

9         }

 当然，3.0允许程序员不必显示声明投射的类型，而可以使用匿名类型，如下代码所示：

 1 public static void List2(string rootDirectory, string searchPattern)

 2         {

 3             var files = from fileName in Directory.GetFiles(rootDirectory, searchPattern)

 4                         select new 

 5                         {

 6                             Name = fileName,

 7                             LastWriteTime = File.GetLastWriteTime(fileName)

 8                         };

 9             foreach (var file in files)

10             {

11                 Console.WriteLine(".{0}({1})", file.Name, file.LastWriteTime);

12             }

13         }

如果select的原始数据的列特别多，改变投射类型则显得十分有优势，只需选出需要关注的几列即可，而不用全部都检索出来。

3、筛选（where）

筛选条件靠断言来表示，即返回布尔值的一个，真就接受，假就放弃。代码如下,功能是筛选出一个月之前修改的文件：

 1  static void FindMonthOldFiles(string rootDirectory, string searchPattern)

 2         {

 3             // 筛选出一个月之前访问的数据

 4             IEnumerable<FileInfo> files = from fileName in Directory.GetFiles(rootDirectory, searchPattern)

 5                                           where File.GetLastWriteTime(fileName) < DateTime.Now.AddMonths(-1)

 6                                           select new FileInfo(fileName);

 7             foreach (FileInfo file in files)

 8             {

 9                 string relativePath = file.FullName.Substring(3);

10                 Console.WriteLine(".{0}.({1})", relativePath, file.LastWriteTime);

11             }

12         }

4、排序

下面代码展示了一种排序：首先按照文件名长度降序排序，然后按照文件名升序排序（不显示声明升序还是降序的，默认升序）：

 IEnumerable<string> fileNames = from fileName in Directory.GetFiles(rootDirectory,searchPattern)

                                            orderby (new FileInfo(fileName)).Length descending,fileName

                                            select fileName;

多个排序条件用逗号隔开，重要性依次降低。但是如果我想投射一个FileInfo的集合怎么办呢？可能会有如下代码：

1             IEnumerable<FileInfo> fileNames = from fileName in Directory.GetFiles(rootDirectory,searchPattern)

2                                             orderby (new FileInfo(fileName)).Length descending,fileName

3                                             select new FileInfo(fileName);

那么问题来了。看第2行与第3行，这样写会每一次访问，都会实例化两个FileInfo，十分浪费系统资源，于是C#3.0隆重推出了let字句。

5、let子句

let 子句添加的表达式可以在整个查询表达式的范围内使用，从而避免重复实例化，写法如下：

1 IEnumerable<FileInfo> fileNames = from fileName in Directory.GetFiles(rootDirectory,searchPattern)

2                                               let file = new FileInfo(fileName)

3                                               orderby file.Length descending, fileName

4                                               select file;

6、编译

实际上，使用查询运算符与查询表达式对CIL CLR没有影响，编译器会将查询表达式转化成标准查询运算符。虽然属于语法糖级别的，但是平时尽可能多使用查询表达式，除非在某些特定情况下，再使用标准查询运算符。