LINQ 和Enumerable类

public class LinqClass
    {
        public static void Test1()
        {
            int[] scores = { 90, 92, 42, 46, 37, 32, 74, 5, 16, 32 };
            IEnumerable<int> scoreQuery =
                from score in scores     //必须
                where score > 40           //可选条件
                orderby score descending //可选条件
                select score;            //必须
            foreach (int score in scoreQuery)
            {
                Console.WriteLine(score);
            }

            int hightestScore = scores.Max();

            //group 分组
            var queryGroups =
                from score in scores
                group score by score;

            //into 存储查询的内容
            //// percentileQuery is an IEnumerable<IGrouping<int, Country>>
            var percentileQuery =
                from score in scores
                group score by score into scorequery
                where scorequery.Key > 10
                select scorequery;

            //在 from 开始子句以及 select 或 group 结束子句之间，
            //所有其他子句（where、join、orderby、from、let）都是可选的。
            //任何可选子句都可以在查询正文中使用零次或多次。

            //let 子句
            //使用 let 子句可以将表达式（如方法调用）的结果存储到新的范围变量中。
            string[] names = { "a n", "b c", "c n", "d m" };
            IEnumerable<string> queryFirstNames =
                from name in names
                let firstName = name.Split(new char[] { ‘ ‘ })[0]
                select firstName;

            //对一个序列应用累加器函数。
            //Aggregate<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>)
            string sentence = "the quick brown fox jumps over the lazy dog";
            string[] words = sentence.Split(‘ ‘);
            string reversed = words.Aggregate((wording, next) => wording + " " + next);
            Console.WriteLine(reversed);

            //确定是否对序列中的所有元素都满足条件。
            //All<TSource>(IEnumerable<TSource>, Func<TSource, Boolean>)

            //确定序列是否包含任何元素。
            //Any<TSource>(IEnumerable<TSource>)
            List<int> numbers = new List<int> { 1, 2 };
            bool hasElements = numbers.Any();
            Console.WriteLine("The list {0} empty.",
                hasElements ? "is not" : "is");

            // 返回输入类型化为 IEnumerable<T>。
            // AsEnumerable<TSource>(IEnumerable<TSource>)

            //将强制转换的元素 IEnumerable 为指定的类型。符合规则热任意类型，与上面的区别。
            //Cast<TResult>(IEnumerable)

            //计算序列的平均值 Double 值。
            //Average(IEnumerable<Double>)

            //连接两个序列。
            //Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

            //确定序列是否包含指定的元素使用的默认相等比较器。
            //Contains<TSource>(IEnumerable<TSource>, TSource)

            //返回序列中的元素数。
            //Count<TSource>(IEnumerable<TSource>)

            //返回单一实例集合中指定的序列或类型参数的默认值的元素，如果序列为空。
            //DefaultIfEmpty<TSource>(IEnumerable<TSource>)

            //通过使用的默认相等比较器对值进行比较从序列返回非重复元素。
            //Distinct<TSource>(IEnumerable<TSource>)

            //返回序列中的指定索引处的元素。
            //ElementAt<TSource>(IEnumerable<TSource>, Int32)

            //通过使用默认的相等比较器对值进行比较，生成两个序列的差集。
            //Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
            double[] numbers1 = { 2.0, 2.1, 2.2, 2.3, 2.4, 2.5 };
            double[] numbers2 = { 2.2 };
            IEnumerable<double> onlyInFirstSet = numbers1.Except(numbers2);
            foreach (double number in onlyInFirstSet)
                Console.WriteLine(number);

            //返回一个序列的第一个元素。
            //First<TSource>(IEnumerable<TSource>)

            //返回序列中满足指定条件的第一个元素。
            //FirstOrDefault<TSource>(IEnumerable<TSource>)

            //根据指定的键选择器函数对序列的元素进行分组。
            //GroupBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

            //    通过使用默认的相等比较器对值进行比较，生成两个序列的交集。
            //Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
            int[] id1 = { 44, 26, 92, 30, 71, 38 };
            int[] id2 = { 39, 59, 83, 47, 26, 4, 30 };
            IEnumerable<int> both = id1.Intersect(id2);
            foreach (int id in both)
                Console.WriteLine(id);

            //通过使用默认的相等比较器生成的两个序列的并集。
            //Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

            //返回一个序列的最后一个元素。
            //Last<TSource>(IEnumerable<TSource>)

            // 从序列的开头返回指定的数量的连续元素。
            // Take<TSource>(IEnumerable<TSource>, Int32)

            // 返回序列中的最大值 Decimal 值。
            //Max(IEnumerable<Decimal>)

            //返回序列的唯一元素；如果该序列并非恰好包含一个元素，则会引发异常。
            //Single<TSource>(IEnumerable<TSource>)

            //ToDictionary<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

            //Where<TSource>(IEnumerable<TSource>, Func<TSource, Boolean>)

            // 一个序列的每个元素投影 IEnumerable<T> 并将合并为一个序列将结果序列。
            //SelectMany<TSource, TResult>(IEnumerable<TSource>, Func<TSource, IEnumerable<TResult>>)
        }
    }