Pro LINQ 之二：LINQ to Objects

最新推荐文章于 2012-10-18 15:32:32 发布

weixin_30826761

最新推荐文章于 2012-10-18 15:32:32 发布

阅读量77

点赞数

原文链接：http://www.cnblogs.com/Abbey/archive/2011/07/14/2104836.html

版权

写在前面

LINQ to Objects，是整个LINQ的支柱。而LINQ的语法，又存在类sql语言和扩展方法调用两种书写方式。从个人的习惯或者喜好出发，在LINQ to Objects上，我更倾向于使用后者。客观上，使用扩展方法的编译，也比类sql语言的方式更直接和效率。

P54 LINQ to Objects的三大核心

IEnumerable<T>、序列、标准查询运算符是LINQ to Objects的三大核心。

其中，序列即数据源，需要支持IEnumerable接口。而序列的元素，则是序列的单位项，通常作为LINQ语句中形式参数的一种象征，出现在首个参数与返回值位置。扩展方法，或者说查询的运算符，是委托delegate的一种变形，这些方法均以序列的元素为首个参数，其本身则是构成LINQ子句的基本单位。

对LINQ to Objects而言，查询运算的第一个参数与查询的结果，均为IEnumerable<T>类型。查询运算，如P14所言，大多均为迟延查询，即在查询结果被引用时，查询才真正被执行。所以，LINQ语句的错误，也通常要在查询结果被引用、遍历时才会被发现，因此不要认为LINQ语句通过了编译检查，就是bug-free的了。

LINQ的迟延查询，可以用下面一段代码作为示意：

// 准备数据源
string[] strings = { "one", "two", null, "three" };

// 定义LINQ查询
Console.WriteLine("Before LINQ declared.");
IEnumerable<string> ieStrings = strings.Where(s => s.Length == 3);
Console.WriteLine("After LINQ declared.");

// 执行查询，对序列进行遍历
foreach (string s in ieStrings)
    Console.WriteLine("Processing  {0}", s);

由于字符串数组strings中有一个元素为null，查询会触发一个空引用的异常。而我们要注意的是，这个异常是在foreach循环已经遍历并输出元素one与two后触发的，因此可以确定之前定义的LINQ查询，直到foreach循环引用序列中的元素中时才被执行。而另一方面，ToArray()、ToList()以及一些聚合操作，则是即时查询或生成的。

P58 LINQ中的函数委托 Func<>

LINQ中的标准查询运算符，大多都需要一个委托作为参数。这个委托，通常被表达为如下形式：

public delegate TR Func<TR>();
public delegate TR Func<T0, TR>(T0 a0);
public delegate TR Func<T0, T1, TR>(T0 a0, T1 a1);
public delegate TR Func<T0, T1, T2, TR>(T0 a0, T1 a1, T2 a2);
public delegate TR Func<T0, T1, T2, T3, TR>(T0 a0, T1 a1, T2 a2, T3 a3);

其中，T0通常代表作为数据源的输入序列，TR则代表作为结果的输出序列并且总在参数的最末尾。

P59 标准查询运算符列表

MSDN中的链接相比书中的更完整：标准查询运算符概述

LINQ的查询符，涉及提取元素的多可带Func<T, bool>的判断子，涉及判断和比较元素的多可带IComparer<T>或IEqualityComparer<T>的比较子。其中IComparer是三元的（1/0/-1），IEqualityComparer是二元的（true/false）。

Visual Studio的智能提示，对于我这样经常忘记运算符重载形式的人编写LINQ，帮助很大！

迟延运算符

注：运算符触发的异常，通常是因为元素为null。

P65 Where

重点是Where的第2种形式，其中引入了序列的索引值作为Func<>的参数。其中，p指代序列元素，i指代序列索引。

//public static IEnumerable<T> Where<T>(
//                            this IEnumerable<T> source,
//                            Func<T, int, bool> predicate);
IEnumerable<string> sequence = presidents.Where((p, i) => (i & 1) == 1);

P68 Select

同样有个引入了序列索引的、类似Where形式2的形式。

var nameObjs = presidents.Select((p, i) => new { Index = i, LastName = p });

Where与Select的结合：从字符串中找出所有Unicode编码的汉字。

string source = @"我wo 是shi 中zhong 国guo 人ren";
char[] result = source
    .Where(c => (c >= 0x4e00 && c <= 0x9fa5))
    .Select(c => c).ToArray();

P73 SelectMany

SelectMany的源是序列，源的元素也是序列，查询返回的结果是源的元素的元素。可以理解为，按1:M的规则，把序列中的每个元素再拆成多个子元素。它同样有个引入序列索引的形式：

IEnumerable<char> chars = presidents
        .SelectMany((p, i) => i < 5 ? p.ToArray() : new char[] { });

上述语句，会把字符串数组中的前5个字符串全部拆成单个字符放入查询结果chars中。

P77 Take-TakeWhile－Skip－SkipWhile

Take	从序列首部开始，取出固定数目的元素
TakeWhile	从序列首部开始，取出符合条件的元素，直到遇到第一个条件不匹配的元素时停止，类似do...while
Skip	从序列首部跳过N个元素
SkipWhile	从序列首部，跳过符合条件的元素，直到遇到第一个不匹配的元素时停止。

P83 Concat

Concat合并两个序列，保存重复项（区别于Union)。连接2个以上的序列，有个小技巧

new[]{sequence1, sequence2, …}.SelectMany()

IEnumerable<string> items = new[] {
                            presidents.Take(5),
                            presidents.Skip(5)
                            }.SelectMany(s => s);

P86 OrderBy-OrderByDescending-ThenBy-ThenByDescending-Reverse

Order排序的难点在第2个形式，引入一个比较子IComparer<T>。

public static IOrderedEnumerable<T> OrderBy<T, K>(
                            this IEnumerable<T> source,
                            Func<T, K> keySelector,
                            IComparer<K> comparer);

在先前的.NET版本中，比较子通常是经由接口IComparable与IComparer实现的。在MSDN的知识库中有个例子：如何使用 IComparable 和 IComparer 接口在 Visual C# 中。

通过派生于IComparable变身比较器的容器，再内嵌IComparer的子类作为比较器，将可以通过Array.Sort(cars, car.sortYearAscending())这样的方式提供特定成员的比较器。

另一方面，通过实现自IComparable派生来的接口方法Compare()，为Array.Sort(cars)这样的调用提供默认的比较器。

public class car : IComparable
{
    // 使用内嵌的IComparer派生类，构造特定成员的比较器
    private class sortYearAscendingHelper : System.Collections.IComparer
    {
        int System.Collections.IComparer.Compare(object a, object b)
        {
            car c1 = (car) a;
            car c2 = (car) b;

            if (c1.year > c2.year)
                return 1;
            if (c1.year < c2.year)
                return -1;
            else
                return 0;
        }
    }

    // 利用嵌套类，暴露特定成员的比较器
    public static System.Collections.IComparer sortYearAscending()
    {
        return (System.Collections.IComparer) new sortYearAscendingHelper();
    }

    // 实现派生的IComparable.CompareTo()方法，提供类car默认的比较子
    int IComparable.CompareTo(object obj)
    {
        car c = (car) obj;
        if (this.year > c.year)
            return 1;
        if (this.year < c.year)
            return -1;
        else
            return 0;
    }

    private int year;
    public car(int Year)
    {
        year = Year;
    }
}

时代在进步，自.NET 2.0引入泛型之后，IComparer<T>接口进入我们的视野。通过从IComparer<T>派生子类，将直接生成对应于类型T的比较子，从而实现OrderBy((o=>o), new BoxComp())这样的排序。

public class BoxComp : IComparer<Box>
{
    public int Compare(Box x, Box y)
    {
        if (x.Height.CompareTo(y.Height) != 0)
        {
            return x.Height.CompareTo(y.Height);
        }
        else if (x.Length.CompareTo(y.Length) != 0)
        {
            return x.Length.CompareTo(y.Length);
        }
        else if (x.Width.CompareTo(y.Width) != 0)
        {
            return x.Width.CompareTo(y.Width);
        }
        else
        {
            return 0;
        }
    }
}

Reverse()就是简单地逆排序。

P102 Join－GroupJoin

Join的过程：用内选择子筛选内序列，用返回的对象借由外选择子筛选外序列，再按内外1:1的方式对匹配的内外元素调用结果的选择子生成结果序列中的元素。其中，外序列是主动的、必取的，在取出外元素的基础上，向结果选择子中添加匹配的内元素。结果选择子lambda表达式左边的参数是(outer, inner)。

public static IEnumerable<V> Join<T, U, K, V>(
                    this IEnumerable<T> outer,                    // 外序列
                    IEnumerable<U> inner,                        // 内序列
                    Func<T, K> outerKeySelector,                // 外选择子
                    Func<U, K> innerKeySelector,                // 内选择子
                    Func<T, U, V> resultSelector);                // 结果选择子

GroupJoin与Join的最大区别，在于GroupJoin是外内1:M的的匹配，即类似于数据库中父子表间通过外键FK建立的1:M的连接。其结果选择子Func<>中的第2个参数为IEnumerable<U>而不是U，因此选择子lambda表达式左边的参数表现为(outer, inners)。通常地，GroupJoin与inners.DefaultIfEmpty配合，可以得到左外连接的效果。

var employeeOptions = employees
                        .GroupJoin(
                        empOptions,                // 内序列
                            e => e.id,                // 外选择子，其作用范围穿透至结果选择子内部
                            o => o.id,                // 内选择子，其作用范围无法穿透至结果选择子
                            (e, os) => os            // 结果选择子
                                .DefaultIfEmpty()    // 如果没有匹配的内元素，即用Default替代
                                // 用内结果序列IEnumerable<EmployeeOption>构造新的序列
                                .Select(o => new    
                                    {
                                        id = e.id,
                                        name = e.firstName,
                                        //  内元素可能为null，故判断之
                                        options = o != null ? o.optionsCount : 0
                                    }))
                     // 得到序列IEnumerable<IEnumerable<匿名类>>，遂SelectMany拆解之
                        .SelectMany(r => r);

P106 GroupBy

经GroupBy()运算后，原IEnumerable<T>的序列将得到一个KeyValuePair<key, T>的序列。GroupBy()使用IEqualityComparer<>比较子，重载形式颇多。

P112 Distinct－Union－Intersect－Except

Distinct	剔除序列中的重复项
Union	并集
Intersect	交集
Except	减集

P117 Cast－OfType－AsEnumerable

同前所述，多用OfType，少用Cast。这与C#的强制类型转换与as关键字或者TryParse()的区别是类似的。

AsEnumerable是将支持IEnumerable<T>的序列变为IEnumerable<T>，从而屏蔽其原本自有的属性与方法（包括运算符）。比如A派生于IEnumerable<T>，有特型化的Where、Select等运算符，经AsEnumerable()后，便只提供IEnumerable<T>默认的运算符了。

P128 Range－Repeat－Empty

Range(int start, int count)	产生一个从start开始，count个的整数序列
Repeat<T>(int count)	产生一个重复count次的T类型序列
Empty<T>()	产生一个空的T类型序列

非迟延运算符