C# 课程 - 第10课：LINQ 简介，LINQ to Objects 第一部分

代码

            Console.WriteLine("\n-----------------ORDERBY");
            Console.WriteLine("--first version");
            cars = CarBrands.OrderBy(s => s.Length);
            foreach (string car in cars)
            {
                Console.WriteLine(car);
            }
            Console.WriteLine("--second version");
            MyStringComparer comparer = new MyStringComparer();
            cars = CarBrands.OrderBy((s => s), comparer);
            foreach (string car in cars)
            {
                Console.WriteLine(car);
            }

结果

• OrderByDescending - 与 OrderBy 相同，但按降序排序。也有两个原型：
  • public static IOrderedEnumerable<T> OrderByDescending<T, K>(this IEnumerable<T> source,Func<T, K> keySelector) where K : IComparable<K>; - 此函数接受输入序列源和委托函数 keySelector，该函数接收源的每个元素并基于该元素返回一个键。然后，此方法根据此键对输入序列中的所有元素进行降序排序。keySelector 返回的键的类型必须实现 IComparable 接口。
  • public static IOrderedEnumerable<T> OrderByDescending<T, K>(this IEnumerable<T> source,Func<T, K> keySelector,IComparer<K> comparer); - 与第一个版本类似，但在这里你将 IComparer 对象传递给此函数，它将执行两个 K 实例的比较。在这种情况下，keySelector 返回的值不一定需要实现 IComparable。

代码

            Console.WriteLine("\n-----------------ORDERBYDESCENDING");
            Console.WriteLine("--first version");
            cars = CarBrands.OrderByDescending(s => s.Length);
            foreach (string car in cars)
            {
                Console.WriteLine(car);
            }
            Console.WriteLine("--second version");
            cars = CarBrands.OrderByDescending((s => s), comparer);
            foreach (string car in cars)
            {
                Console.WriteLine(car);
            }

结果

• ThenBy - 此操作符接受已排序的序列（作为 IOrderedEnumerable）并根据返回键值的函数再次对其进行排序。有两个原型：
  • public static IOrderedEnumerable<T> ThenBy<T, K>(this IOrderedEnumerable<T> source,Func<T, K> keySelector)where K : IComparable<K>; - 此函数接受 IOrderedEnumerable 序列作为输入，并返回相同的数据结构作为输出。keySelector 委托接收输入序列的每个元素并基于输入元素返回一个键。返回的键必须实现 IComparable。
  • public static IOrderedEnumerable<T> ThenBy<T, K>(this IOrderedEnumerable<T> source,Func<T, K> keySelector,IComparer<K> comparer); - 与第一个版本相同，但返回的键实现 IComparer。

代码

            Console.WriteLine("\n-----------------THENBY");
            Console.WriteLine("--first version");
            cars = CarBrands.OrderBy(s => s.Length).ThenBy(s => s);
            foreach (string car in cars)
            {
                Console.WriteLine(car);
            }
            Console.WriteLine("--second version");
            comparer = new MyStringComparer();
            cars = CarBrands.OrderBy(s => s.Length).ThenBy(s=>s, comparer);
            foreach (string car in cars)
            {
                Console.WriteLine(car);
            }

结果

关于 ThenBy 操作符的一个重要说明是，它保证如果方法依次接收的两个元素的输入序列具有相同的键值，它们在输出序列中的顺序将完全相同。

• ThenByDescending - 与上一个操作符完全相同，但按降序排序。
  • public static IOrderedEnumerable<T> ThenByDescending<T, K>(this IOrderedEnumerable<T> source,Func<T, K> keySelector)where K : IComparable<K>; - 此函数接受 IOrderedEnumerable 序列作为输入，并返回相同的数据结构作为输出。keySelector 委托接收输入序列的每个元素并基于输入元素返回一个键。返回的键必须实现 IComparable。
  • public static IOrderedEnumerable<T> ThenByDescending<T, K>(this IOrderedEnumerable<T> source,Func<T, K> keySelector,IComparer<K> comparer); - 与第一个版本相同，但返回的键实现 IComparer。

代码

            Console.WriteLine("\n-----------------THENBYDESCENDING");
            Console.WriteLine("--first version");
            cars = CarBrands.OrderBy(s => s.Length).ThenByDescending(s => s);
            foreach (string car in cars)
            {
                Console.WriteLine(car);
            }
            Console.WriteLine("--second version");
            comparer = new MyStringComparer();
            cars = CarBrands.OrderBy(s => s.Length).ThenByDescending(s => s, comparer);
            foreach (string car in cars)
            {
                Console.WriteLine(car);
            }

结果

与 ThenBy 类似，ThenByDescending 操作符保证如果方法依次接收的两个元素的输入序列具有相同的键值，它们在输出序列中的顺序将完全相同。

• Reverse - 以相反的顺序返回与输入序列相同的序列。有一个原型：
  • public static IEnumerable<T> Reverse<T>(this IEnumerable<T> source); - 没有复杂的输入参数 source，它表示输入序列。

代码

            Console.WriteLine("\n-----------------REVERSE");
            cars = CarBrands.Reverse();
            foreach (string car in cars)
            {
                Console.WriteLine(car);
            }

结果

• Join - 此操作符返回两个序列中键匹配的元素的组合。具有以下原型：
  • 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); - 这里第一个参数 outer 是我们调用 Join 操作符的序列，因为这个函数是扩展方法。第二个参数 inner 是另一个我们作为输入传递给此方法的序列。首先，为 inner 序列的每个元素调用 innerKeySelector，它将为每个元素返回一个键，并且 inner 序列的每个元素将基于其键存储在哈希表中。接下来，枚举 outer 序列，并为它的每个元素调用 outerKeySelector 来获取其键。如果我们要在 inner 元素的哈希表中找到一个键匹配的元素，那么就会调用 resultSelector。resultSelector 方法将返回 V 类型的实例化对象。

代码

            Console.WriteLine("\n-----------------JOIN");
            int[] Lenghts = { 3, 4, 5, 6, 7, 8, 9 };
            var outStructs = CarBrands.Join(Lenghts, s => s.Length, l => l, (s, l) => new { name = s, length = l });
            foreach (var Car in outStructs)
            {
                Console.WriteLine("Car name is: " + Car.name + " Car name length is: " + Car.length);
            }

结果

• GroupJoin - 对两个输入序列执行分组连接。与 Join 操作符类似，但它将所有匹配的内部元素分组到 outer 序列的一个元素中。该函数具有以下原型：
  • public static IEnumerable<V> GroupJoin<T, U, K, V>(this IEnumerable<T> outer,IEnumerable<U> inner,Func<T, K> outerKeySelector,Func<U, K> innerKeySelector, Func<T, IEnumerable<U>, V> resultSelector); - 这里 outer 参数是我们调用该函数的序列，inner 参数是输入序列。首先，此操作符将调用 innerKeySelector 方法来枚举输入序列的所有 U 类型元素，并将该序列的所有元素存储在由键 K 引用的哈希表中。下一步将为每个 T 类型元素调用 outerKeySelector 以检索其键 K。当检索到键 K 时，它会获取哈希表中所有与键 K 匹配的 inner 序列元素。最后一步将是调用 resultSelector 方法，并将 outer 元素和 inner 元素序列（其键与 outer 元素键匹配）传递给它。

代码

            Console.WriteLine("\n-----------------GROUPJOIN");
            //if car length is bigger than 5 we take all lengths that bigger than 5
            //if car length is smaller or equal 5 we take all lengths that smaller or equal 5
            int[] Len = { 3, 4, 5, 6, 7, 8, 9 };
            var outValues = CarBrands.GroupJoin(Len, s => s.Length > 5, l => l > 5, (s, lens) => new { name = s, lensplus = lens });
            foreach (var car in outValues)
            {
                Console.WriteLine("Car name is: " + car.name + "name length: "+ car.name.Length +" Lengths bigger or smaller and equal than 5: ");
                foreach (int l in car.lensplus) 
                {
                    Console.WriteLine(l);
                }
            }

结果

• GroupBy - 此操作符按公共键对输入序列的元素进行分组。具有以下原型：
  • public static IEnumerable<IGrouping<K, T>> GroupBy<T, K>(this IEnumerable<T> source,Func<T, K> keySelector); - 此函数枚举输入源序列并为每个元素调用 keySelector 方法。然后，使用该元素及其键，该函数会生成 IGrouping<K,T> 序列，其中该组的每个元素是具有相同键的元素序列。键值的比较使用默认的相等比较器。
  • public static IEnumerable<IGrouping<K, T>> GroupBy<T, K>(this IEnumerable<T> source,Func<T, K> keySelector,IEqualityComparer<K> comparer);  - 此原型与第一个完全相同，但你可以将自己的相等比较器放在默认比较器位置。
  • public static IEnumerable<IGrouping<K, E>> GroupBy<T, K, E>(this IEnumerable<T> source,Func<T, K> keySelector,Func<T, E> elementSelector); - 与第一个原型相同，但你可以指定要通过 elementSelector 遍历的元素，而不是整个序列。
  • public static IEnumerable<IGrouping<K, E>> GroupBy<T, K, E>(this IEnumerable<T> source,Func<T, K> keySelector,Func<T, E> elementSelector,IEqualityComparer<K> comparer); - 第四个原型是第二个和第三个的组合，在这里你可以决定要分组的元素，并为键提供自己的比较器。

代码

            Console.WriteLine("\n-----------------GROUPBY");
            Console.WriteLine("--first version");
            IEnumerable<IGrouping<int, string>> grouppedCars = CarBrands.GroupBy(s => s.Length);
            foreach(IGrouping<int, string> element in grouppedCars)
            {
                Console.WriteLine("Length: " + element.Key + " Names:");
                foreach(string s in element)
                {
                    Console.WriteLine(s);
                }
            }
            Console.WriteLine("--second version");
            IntComparer comp = new IntComparer();
            grouppedCars = CarBrands.GroupBy(s => s.Length,comp);
            foreach (IGrouping<int, string> element in grouppedCars)
            {
                Console.WriteLine("Length: " + element.Key + " Names:");
                foreach (string s in element)
                {
                    Console.WriteLine(s);
                }
            }
            Console.WriteLine("--third version");
            IEnumerable<IGrouping<int, int>> grouppedLengths = CarBrands.GroupBy(s => s.Length, el => el.Length);
            foreach (IGrouping<int, int> element in grouppedLengths)
            {
                Console.WriteLine("Length group: " + element.Key + " Cars lengths:");
                foreach (int s in element)
                {
                    Console.WriteLine(s);
                }
            }
            Console.WriteLine("--fourth version");
            grouppedLengths = CarBrands.GroupBy(s => s.Length, el => el.Length, comp);
            foreach (IGrouping<int, int> element in grouppedLengths)
            {
                Console.WriteLine("Length group: " + element.Key + " Cars lengths:");
                foreach (int s in element)
                {
                    Console.WriteLine(s);
                }
            }

结果

• Distinct - 此操作符从输入源中移除所有重复项，并返回一个不包含任何重复项的新序列。具有以下原型：
  • public static IEnumerable<T> Distinct<T>(this IEnumerable<T> source); - 如你所见，这是一个非常简单的函数，我们对其调用源序列，它返回一个相同类型的序列。

代码

            Console.WriteLine("\n-----------------DISTINCT");
            string[] names = { "Sergey", "Sergey", "John", "James", "John", "Mary", "Alexander" };
            IEnumerable<string> dist = names.Distinct();
            foreach (string s in dist)
            {
                Console.WriteLine(s);
            }

结果

• Union - 此操作符返回两个输入序列的唯一值集合，具有以下原型：
  • public static IEnumerable<T> Union<T>(this IEnumerable<T> first,IEnumerable<T> second); - 此函数首先枚举名为 first 的输入序列，并获取尚未获取的元素，然后它以完全相同的方式枚举名为 second 的序列。

代码

            Console.WriteLine("\n-----------------UNION");
            string[] names2 = { "Mary", "Alexander", "James", "Richard", "Julia" };
            IEnumerable<string> uniqueNames = names.Union(names2);
            foreach (string s in uniqueNames)
            {
                Console.WriteLine(s);
            }

结果

• Intersect - 返回两个输入序列的交集。具有以下原型：
  • public static IEnumerable<T> Intersect<T>(this IEnumerable<T> first,IEnumerable<T> second); - 此函数首先枚举名为 second 的输入序列的元素，只取唯一的元素，然后枚举 first 序列中的元素，取那些在 second 中被枚举过的元素，并将它们放入输出序列。

代码

            Console.WriteLine("\n-----------------INTERSECT");
            IEnumerable<string> intersNames = names.Intersect(names2);
            foreach (string s in intersNames)
            {
                Console.WriteLine(s);
            }

结果

• Except - 此操作符返回 first 序列中不存在于 second 序列中的所有元素。存在以下函数原型：
  • public static IEnumerable<T> Except<T>(this IEnumerable<T> first,IEnumerable<T> second); - 非常简单的函数。我们在 first 序列上调用它，并将 second 作为输入。

代码

            Console.WriteLine("\n-----------------EXCEPT");
            IEnumerable<string> exceptNames = names.Except(names2);
            foreach (string s in exceptNames)
            {
                Console.WriteLine(s);
            }

结果

• Cast - 此操作符将输入序列的每个元素转换为特定类型的输出序列。有一个原型：
  • public static IEnumerable<T> Cast<T>(this IEnumerable source); - 如你所见，此操作符在类型为 IEnumerable 的序列 source 上调用。如你从前面的所有操作符中看到的，大多数操作符接受 IEnumearble<T> 而不是 IEnumearble，所以请不要感到困惑，这确实是不同的。注意：cast 将尝试将输入序列的每个对象转换为输出序列类型。如果某个对象不可转换，你将收到 InvalidCastException。

代码

            Console.WriteLine("\n-----------------CAST");
            int[] integers = { 1, 2, 3, 4, 5, 6, 7 };
            IEnumerable<object> objs = integers.Cast<object>();
            foreach (object s in objs)
            {
                Console.WriteLine(s.ToString());
            }

结果

• OfType - 此操作符与 Cast 类似，但它只返回可以转换为输出序列类型的元素。它具有以下原型：
  • public static IEnumerable<T> OfType<T>(this IEnumerable source); - 与 Сast 相同，它接受 IEnumerable 接口。

代码

            Console.WriteLine("\n-----------------OFTYPE");
            IEnumerable<string> strs = integers.OfType<string>();//here we'll receive empty string
            foreach (string s in strs)
            {
                Console.WriteLine(s.ToString());
            }

结果

• DefaultIfEmpty - 如果输入序列为空，此函数将返回包含默认值的序列。具有以下原型：
  • public static IEnumerable<T> DefaultIfEmpty<T>(this IEnumerable<T> source); - 此函数在输入序列 source 上调用。如果输入序列为空，它将返回输入序列的默认值 <T>，对于引用类型和可空类型，它为 null。
  • public static IEnumerable<T> DefaultIfEmpty<T>(this IEnumerable<T> source,T defaultValue); - 与第一个相同，但允许设置默认值。

代码

            Console.WriteLine("\n-----------------DEFAULTIFEMPTY");
            Console.WriteLine("--first version");
            IEnumerable<int> sequence = integers.Where(i => i>10);
            IEnumerable<int> outseq = sequence.DefaultIfEmpty();//here we should have default int value
            Console.WriteLine("Result on empty:");
            foreach(int i in outseq)
            {
                Console.WriteLine(i);
            }
            sequence = integers.Where(i => i > 5);
            outseq = sequence.DefaultIfEmpty();//here we should have default int value
            Console.WriteLine("Result on not empty:");
            foreach (int i in outseq)
            {
                Console.WriteLine(i);
            }
            Console.WriteLine("--second version");
            sequence = integers.Where(i => i > 10);
            outseq = sequence.DefaultIfEmpty(55);//here we should have default int value
            Console.WriteLine("Result on empty:");
            foreach (int i in outseq)
            {
                Console.WriteLine(i);
            }

结果

• Range - 生成整数序列，具有以下原型：
  • public static IEnumerable<int> Range(int start,int count);

代码

            Console.WriteLine("\n-----------------RANGE");
            IEnumerable<int> intseq = Enumerable.Range(5, 5);
            foreach (int i in intseq)
            {
                Console.WriteLine(i);
            }

结果

• Repeat - 此操作符生成一个输出序列，该序列包含特定输入元素指定的次数。有一个原型：
  • public static IEnumerable<T> Repeat<T>(T element,int count);

代码

            Console.WriteLine("\n-----------------REPEAT");
            intseq = Enumerable.Repeat(5, 5);
            foreach (int i in intseq)
            {
                Console.WriteLine(i);
            }

结果

• Empty - 生成特定类型的空序列。有一个原型：
  • public static IEnumerable<T> Empty<T>();

代码

            Console.WriteLine("\n-----------------EMPTY");
            intseq = Enumerable.Empty<int>();
            foreach (int i in intseq)
            {
                Console.WriteLine(i);//we should never reach here
            }

结果

来源

1. Pro LINQ Language Integrated Query in C# 2010 Adam Freeman and Joseph C. Rattz, Jr.
2. https://msdn.microsoft.com
3. https://codeproject.org.cn/Articles