LINQ之路16：LINQ Operators之集合运算符、Zip操作符、转换方法、生成器方法

本篇将是关于LINQ Operators的最后一篇，包括：集合运算符（Set Operators）、Zip操作符、转换方法（Conversion Methods）、生成器方法（Generation Methods）。集合运算符用语对两个sequence进行操作；Zip运算符同步遍历两个sequence（像一个拉链一样），返回的sequence基于在每一个元素对上应用lambda表达式；转换方法用来将实现了IEnumerable<T>的sequence转换到其他类型的集合，或从其他类型的集合转换到sequence；生成器方法/Generation Methods用来创建简单的本地sequence。

集合运算符/Set Operators

IEnumerable<TSource>, IEnumerable<TSource>→IEnumerable<TSource>

Operator	说明	SQL语义
Concat	连接两个sequences的所有元素	UNION ALL
Union	连接两个sequences的所有元素，但去除重复的元素	UNION
Intersect	返回在两个sequence中都存在的元素	WHERE ... IN (...)
Except	返回存在于第一个sequence而不存在于第二个sequence中的元素	EXCEPT or WHERE   ... NOT IN (...)

Concat和Union

Concat返回第一个sequence中的所有元素，后接第二个sequence中的所有元素，即连接两个sequence。Union完成相同的工作，但是会去除重复的元素。

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

如果两个sequence的类型不同但是他们的元素共享同一个基类型时，我们通常明确指定类型参数。比如，在使用反射API时，方法和属性分别用MethodInfo和PropertyInfo类型表示，他们的共同基类是 MemberInfo。我们可以在调用Concat时明确指定基类型来连接方法和属性：

            MethodInfo[] methods = typeof(string).GetMethods();
            PropertyInfo[] props = typeof(string).GetProperties();
            IEnumerable<MemberInfo> both = methods.Concat<MemberInfo>(props);

下面的示例中，我们在连接之前先对Methods进行了过滤：

            var methods = typeof(string).GetMethods().Where(m => !m.IsSpecialName);
            var props = typeof(string).GetProperties();
            var both = methods.Concat<MemberInfo>(props);

有意思的是，这个示例可以在C# 4.0中编译但不能在C# 3.0中编译，因为它依赖于接口类型参数协变：methods的类型是IEnumerable<MethodInfo>，在其转换为IEnumerable<MemberInfo>时需要C# 4.0提供的协变功能。这个例子很好的说明了协变如何让事情按我们期望的方式来工作。

Intersect和Except

Intersect返回两个sequence中都存在的元素；Except返回存在于第一个sequence而不存在于第二个sequence中的元素：

            int[] seq1 = { 1, 2, 3 }, seq2 = { 3, 4, 5 };
            IEnumerable<int>
            commonality = seq1.Intersect(seq2), // { 3 }
            difference1 = seq1.Except(seq2), // { 1, 2 }
            difference2 = seq2.Except(seq1); // { 4, 5 }

Enumerable.Except的内部工作方式是：把第一个sequence中的所有元素装载到一个dictionary中，然后从这个dictionary中移除所有存在于第二个sequence中的元素。它等价于SQL中的NOT EXISTS或NOT IN子查询：

            SELECT number FROM numbers1Table
            WHERE number NOT IN (SELECT number FROM numbers2Table)

The Zip Operator

IEnumerable<TFirst>, IEnumerable<TSecond>→IEnumerable<TResult>

Zip运算符在Framework 4.0被添加进来。它同步遍历两个sequence（像一个拉链一样），返回的sequence基于在每一个元素对上应用lambda表达式。如下例：

            int[] numbers = { 3, 5, 7 };
            string[] words = { "three", "five", "seven", "ignored" };
            IEnumerable<string> zip = numbers.Zip (words, (n, w) => n + "=" + w);
 
            // 产生的sequence包含如下元素
            // 3=three
            // 5=five
            // 7=seven

任何输入sequence中额外的元素（不能组成元素对）会被忽略。Zip运算符在查询数据库时不被支持。

转换方法/Conversion Methods

LINQ主要用来处理sequences：即IEnumerable<T>类型的集合。 转换方法用来将sequence转换到其他类型的集合，或从其他类型的集合转换到sequence。

方法	说明
OfType	把IEnumerable转换到IEnumerable<T>，丢弃错误的类型元素
Cast	把IEnumerable转换到IEnumerable<T>，如果存在错误的类型元素则抛出异常
ToArray	把IEnumerable<T>转换到T[]
ToList	把IEnumerable<T>转换到List<T>
ToDictionary	把IEnumerable<T>转换到Dictionary<TKey,TValue>
ToLookup	把IEnumerable<T>转换到ILookup<TKey,TElement>
AsEnumerable	向下转换到IEnumerable<T>
AsQueryable	转换到IQueryable<T>

OfType和Cast

OfType和Cast接收一个非泛型的IEnumerable集合，返回一个泛型的IEnumerable<T>，这样我们就可以对其进行查询了。

            ArrayList classicList = new ArrayList(); // in System.Collections
            classicList.AddRange(new int[] { 3, 4, 5 });
            IEnumerable<int> sequence1 = classicList.Cast<int>();

Cast和OfType的不同行为表现在当遇到一个类型不兼容的输入元素时，Cast抛出一个异常，而OfType忽略不兼容的元素。继续上一个示例：

            DateTime offender = DateTime.Now;
            classicList.Add(offender);
            IEnumerable<int>
            sequence2 = classicList.OfType<int>(), // OK - ignores offending DateTime
            sequence3 = classicList.Cast<int>(); // Throws exception

判断元素类型是否兼容的规则与C#的is操作符一致，我们可以通过OfType的内部实现来进行验证：

        public static IEnumerable<TSource> OfType<TSource>(IEnumerable source)
        {
            foreach (object element in source)
                if (element is TSource)
                    yield return (TSource)element;
        }

Cast具有相同的实现，除了它里面省略了类型兼容性的检测：

        public static IEnumerable<TSource> Cast<TSource>(IEnumerable source)
        {
            foreach (object element in source)
                yield return (TSource)element;
        }

这些实现的一个结果是我们无法使用Cast来进行数值或定制的转换（对这些我们必须使用Select运算符）。换句话说，Cast不具备C#中cast操作符的灵活性：

            int i = 3;
            long l = i;         // 隐式数值转换 int->long
            int i2 = (int)l;    // 显式数值转换 long->int

现在我们再来看看OfType和Cast转换int sequence到long sequence的行为：

            int[] integers = { 1, 2, 3 };
            IEnumerable<long> test1 = integers.OfType<long>();
            IEnumerable<long> test2 = integers.Cast<long>();

当我们遍历结果时，test1产生0个元素的sequence，而test2会抛出异常。我们再次审视OfType的实现，原因显而易见。用int代入TSource之后，下面的表达式(element is long)返回false，因为int和long之间并没有继承关系。

而test2抛出异常的原因就没那么明显了，注意Cast的实现中元素的类型为object。当TSource是一个值类型时， CLR认为这是一个拆箱转换。而拆箱操作要求精确的类型匹配，所以当TSource是一个int时，object-to-long拆箱会失败并抛出异常。可以通过下面的示例进行验证：

            int value = 123;
            object element = value;
            long result = (long)element; // exception

正如我们前面的建议，此问题的解决方案是使用Select：

            IEnumerable<long> castLong = integers.Select(s => (long)s);

当我们需要把一个泛型的输入sequence中的元素向下转换（转为更具体的类型）时，OfType和Cast也会非常有用。比如，如果我们有一个IEnumerable<Fruit>的输入sequence，OfType<Apple>仅返回apples，这在我们稍后会讲到的LINQ to XML中会特别有效。

Cast有对应的查询表达式语法支持：只需在范围变量之前指定一个类型即可：

            var query =
                from TreeNode node in myTreeView.Nodes
                ...

ToArray, ToList, ToDictionary, 和ToLookup

ToArray和ToList分别把结果输出到一个数组或泛型列表。这些运算符会强制对输入sequence进行立即遍历（除非间接通过子查询或表达式树）。关于他们的示例请参考：LINQ之路 6：延迟执行(Deferred Execution)

ToDictionary和ToLookup接受如下参数：

参数	类型
输入sequence / Input sequence	IEnumerable<TSource>
键选择器 / Key selector	TSource => TKey
元素选择器 / Element selector(optional)	TSource => TElement
比较器 / Comparer (optional)	IEqualityComparer<TKey>

ToDictionary也会强制sequence的立即执行，并把结果写入一个泛型Dictionary。提供的键选择器表达式必须为每个元素产生唯一的键值，否则将会抛出异常。而ToLookup允许多个元素使用同一个键值。对于lookups我们已经在LINQ之路13：LINQ Operators之连接(Joining)中有过详细介绍。

AsEnumerable和AsQueryable

AsEnumerable把一个sequence向上转换到IEnumerable<T>，强制编译器把后来的查询运算符绑定到Enumerable类中的方法，而不是Queryable类的方法。他们的示例请参考LINQ之路8：解释查询（Interpreted Queries）中的“组合使用解释查询和本地查询”一节。

AsQueryable把一个sequence向下转换到IQueryable<T>（如果它实现了该接口）。否则，它会实例化一个IQueryable<T>包装器用于本地查询之上。

生成器方法/Generation Methods

void→IEnumerable<TResult>

Operator	说明
Empty	创建一个空sequence
Repeat	创建一个含有重复elements的sequence
Range	创建一个包含指定整数的sequence

Empty, Repeat, 和Range是Enumerable类的静态方法，而不是扩展方法，用来创建简单的本地sequence。

Empty

Empty创建一个空的sequence，它只需要一个类型参数：

            foreach (string s in Enumerable.Empty<string>())
                Console.Write(s); // <nothing>

通过配合使用??操作符，Empty可以完成DefaultIfEmpty相反的操作。比如，我们有一个交错整形数组，现在我们想要把所有的整数放到一个简单的平展列表中。下面的SelectMany查询在遇到一个空的内部数组时会失败：

            int[][] numbers =
            {
                new int[] { 1, 2, 3 },
                new int[] { 4, 5, 6 },
                null // this null makes the query below fail.
            };
            IEnumerable<int> flat = numbers.SelectMany(innerArray => innerArray);

Empty搭配??就可以解决该问题：

            IEnumerable<int> flat = numbers
                .SelectMany(innerArray => innerArray ?? Enumerable.Empty<int>());
            foreach (int i in flat)
                Console.Write(i + ""); // 1 2 3 4 5 6

Range 和Repeat

Range和Repeat只能用来操作integers。Range接受一个起始索引和元素个数：

            foreach (int i in Enumerable.Range(5, 5))
                Console.Write(i + ""); // 5 6 7 8 9

Repeat接受重复的数值，和该数值重复的次数：

            foreach (int i in Enumerable.Repeat(5, 3))
                Console.Write(i + ""); // 5 5 5

通过六篇博客的篇幅，我们对于LINQ Operators的介绍终于告一段落了，我也长舒了一口气。一方面希望给阅者最全面最详细的介绍，另一方面又怕再不结束LINQ Operators，只怕阅者都会产生审美疲劳了，^_^！

关于LINQ，我们还有一块没有介绍，它就是LINQ to XML，我准备用3-4篇左右的篇幅来对它进行讨论，等到LINQ to XML完成的那一天，LINQ之路系列博客也就大功告成了。希望广大博友继续给我支持，给我力量，谢谢。^_^