LINQ之路 4：LINQ方法语法

书写LINQ查询时又两种语法可供选择：方法语法（Fluent Syntax）和查询语法（Query Expression）。

LINQ方法语法是非常灵活和重要的，我们在这里将描述使用链接查询运算符的方式来创建复杂的查询，方法语法的本质是通过扩展方法和Lambda表达式来创建查询。C# 3.0对于LINQ表达式还引入了声明式的查询语法，通过查询语法写出的查询比较类似于SQL查询。本篇会对LINQ方法语法进行详细的介绍。

当然，.NET公共语言运行库（CLR）并不具有查询语法的概念。所以，编译器会在程序编译时把查询表达式转换为方法语法，即对扩展方法的调用。所以使用方法语法会让我们更加接近和了解LINQ的实现和本质，并且一些查询只能表示为方法调用，如检索序列中的最大值、最小值元素的查询，他们在查询语法中就没有对应的实现。但另一方面，查询语法通常会比较简单和易读。不管怎样，这两种语法和互相补充和兼容的，我们可以在一个查询中混合使用方法语法和查询语法。

链接查询运算符

在LINQ介绍中，我们示范了使用单个查询运算符创建的查询。如果需要创建更加复杂的查询，我们可以在表达式之后添加其他查询运算符，产生一个查询链。如下例：查询出所有含有字母”a”的姓名，按长度进行排序，然后把结果全部转换成大写格式。

        static void Main(string[] args)
        {
            string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };

            IEnumerable<string> query = names
                .Where(n => n.Contains("a"))
                .OrderBy(n => n.Length)
                .Select(n => n.ToUpper());
 
            foreach (string name in query) Console.WriteLine(name);
        }
 
        // Result:
        JAY
        MARY
        HARRY

就像在本例中所示，当链接使用查询运算符时，一个运算符的输出sequence会成为下一个运算符的输入sequence，其结果形成了一个sequence的传输链，如图所示：

图：链接查询运算符

Where, OrderyBy, Select这些标准查询运算符对应Enumerable类中的相应扩展方法。Where产生一个经过过滤的sequence；OrderBy生成输入sequence的排序版本；Select得到的序列中的每个元素都经过了给定lambda表达式的转换。

下面是Where, OrderBy, Select这几个扩展方法的签名：

        public static IEnumerable<TSource> Where<TSource>
            (this IEnumerable<TSource> source, Func<TSource, bool> predicate)

        public static IEnumerable<TSource> OrderBy<TSource, TKey>
            (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)

        public static IEnumerable<TResult> Select<TSource, TResult>
            (this IEnumerable<TSource> source, Func<TSource, TResult> selector)

扩展方法的重要性

在LINQ表达式中，正是扩展方法让LINQ查询运算符的链接成为了可能。因为运算符本身是对IEnumerable<T>类型的扩展，并且返回IEnumerable<T>类型的结果。我们可以比较一下使用扩展方法和使用静态方法的区别，结果会一目了然。扩展方法非常自然地反映了从左到右的数据流向，同时保持lambda表达式与查询运算符的位置一致性。

            //   extension methods make LINQ elegant
            IEnumerable<string> query = names
                .Where(n => n.Contains("a"))
                .OrderBy(n => n.Length)
                .Select(n => n.ToUpper());
 
            //   static methods lose query's fluency
            IEnumerable<string> query2 =
                Enumerable.Select(
                    Enumerable.OrderBy(
                        Enumerable.Where(names, n => n.Contains("a")
                        ), n => n.Length
                    ), n => n.ToUpper()
                );

创建Lambda表达式

在上例中，我们向Where运算符提供了如下Lambda表达式：n => n.Contains(“a”)。对各个查询运算符来说，Lambda表达式的目的不尽相同。对于Where，它决定了一个element是否包含在结果sequence中；对于OrderBy，它把每个element映射到比较的键值；而对于Select，lambda表达式则决定了输入sequence中的元素要怎么样的转换再放入输出sequence中。

关于Lambda表达式的详细介绍，请参考LINQ 之路3：C# 3.0的语言功能（下）。

通常来说，查询运算符会对每一个输入sequence中的element来调用我们提供的Lambda表达式，这样就给了我们一个实现自己的逻辑，从而得到自己需要结果的机会。我们可以看一下.NET Framework对Enumerable.Where的实现：

        public static IEnumerable<TSource> Where<TSource>(
            this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            foreach (TSource element in source)
                if (predicate(element))
                    yield return element;
        }

标准查询运算符使用了通用的Func委托，Func是一组定义在System.Linq(谢谢 A_明~坚持的指正，此处应为System)命名空间中的通用委托。它接受一系列的输入参数和一个返回值，返回值对应最后一个参数定义。所以，Func<TSource, bool>委托匹配 TSource => bool表达式，接受TSource输入参数，返回一个bool值。

Lambda表达式和元素类型

标准查询运算符使用统一的类型名称：

通用类型名称	用途
TSource	Input sequence中的element类型
TResult	Output sequence中的element 类型(如果和TSource不相同)
TKey	使用sorting、grouping、joining等的键值类型

TSource由输入sequence决定，而TResult和TKey则从我们提供的Lambda表达式推断得到。

比如：Select查询运算符的签名如下：

        public static IEnumerable<TResult> Select<TSource,TResult>(
            this IEnumerable<TSource> source, Func<TSource,TResult> selector)

Func<TSource,TResult>匹配TSource => TResult的Lambda表达式，接受一个输入参数TSource，返回TResult。因为TSource和TResult是不同的类型，所以我们的Lambda表达式甚至可以改变输入element的数据类型。下面的示例就把string类型元素转换为int类型元素：

        static void TestSelectOperator(){
            string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };
            // 编译器将会从Lambda表达式 n => n.Length推断出TResult为int类型
            IEnumerable<int> query = names.Select(n => n.Length);
 
            foreach (int length in query)
                Console.Write(length + "|");    //  3|4|5|4|3
        }

而对Where查询运算符来讲，它并不需要对输出element进行类型推断，因为它只是对输入elements进行过滤而不作转换，因此输出element和输入element具有相同的数据类型。

对于OrderBy查询运算符来讲，Func<TSource, TKey>把输入元素映射至一个排序键值。TKey由Lambda表达式的结果推断出来，比如我们可以按长度或按字母顺序对names数组进行排序：

            string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };
            IEnumerable<string> sortedByLength, sortedAlphabetically;
            sortedByLength = names.OrderBy(n => n.Length);  // int key
            sortedAlphabetically = names.OrderBy(n => n);   // string key

其他查询运算符

并不是所有的查询运算符都返回一个sequence。元素(element)运算符会从输入sequence中获取单个元素，如：First，Last和ElementAt:

            int[] numbers = { 10, 9, 8, 7, 6 };  
            int firstNumber = numbers.First();                  // 10
            int lastNumber = numbers.Last();                    // 6
            int secondNumber = numbers.ElementAt(1);            // 9
            int lowestNumber = numbers.OrderBy(n => n).First(); // 6

集合(aggregation) 运算符返回一个标量值，通常是数值类型：

            int count = numbers.Count();    // 5
            int min = numbers.Min();        // 6

判断运算符返回一个bool值：

            bool hasTheNumberNine = numbers.Contains(9);    // true
            bool hasElements = numbers.Any();               // true
            bool hasAnOddElement = numbers.Any(n => (n % 2) == 1);  //true

因为这些运算符并不是返回一个sequence，所以我们不能再这些运算符之后链接其他运算符，换句话讲，他们一般出现在查询的最后面。

还有一些查询运算符接受两个输入sequence，比如Concat把一个sequence添加到另外一个sequence后面；Union与Concat类似，但是会去除相同的元素：

            int[] seq1 = { 1, 2, 2, 3 };
            int[] seq2 = { 3, 4, 5 };
            IEnumerable<int> concat = seq1.Concat(seq2);    // { 1, 2, 2, 3, 3, 4, 5 }
            IEnumerable<int> union = seq1.Union(seq2);      // { 1, 2, 3, 4, 5 }