二、C# 高级教程 - 2.14 C# LINQ - 《C# 高级编程》

LINQ
- Language Intergrated Query(Linq) 集成查询语言

LINQ

Language Intergrated Query(Linq) 集成查询语言

using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Linq;
namespace LinqTest
{
    class MainClass
    {
        public static void Main(string[] args)
        {
         /*
          * where        筛选操作符定义了返回元素的条件
          * 
          * Select       投射操作符用于把对象转换为另一个类型的新对象。
          * 
          * OrderBy      排序操作符返回的元素的顺序
          * ThenBy
          * OerderByDescending
          * ThenByDescending
          * Reverse
          * 
          * Join         连接操作符用于合并不直接相关的集合。
          * GroupJoin
          * 
          * GroupBy      组合操作符把数组放在组中。
          * ToLookup
          * 
          * Any          如果元素序列满足指定的条件，限定符操作就返回布尔值
          * All
          * Contains     检查某个元素是否在集合中
          * 
          * Take         分区操作符返回集合的一个子集。指定要从集合中提取的元素个数
          * Skip         跳过指定的元素个数
          * TakeWhile
          * SkipWhile
          * 
          * Distinct     Set操作符返回一个集合。从集合中删除重复的元素。
          * Union        需要两个集合，返回出现在其中一个集合中的唯一元素。
          * Intersect    需要两个集合，返回两个集合都有的元素。
          * Except       需要两个集合，返回只出现在一个集合中的元素。
          * Zip          需要两个集合，把两个集合合并为一个
          * 
          * First        这些元素操作符仅返回一个元素。返回第一个满足条件的元素。
          * FirstOrDefault   返回第一个满足条件的元素。如果没有找到，就返回默认值。
          * Last
          * LastOrDefault
          * ElementAt    指定了要返回的元素的位置
          * ElementAtOrDefault
          * Single       只返回一个满足条件的元素。如果有多个元素都满足条件，就抛出一个异常。
          * SingleOrDefault
          * 
          * Count        聚合操作符计算集合的一个值。利用这些聚合操作符，可以计算所有值的总和、所有元素的个数
          * Sum          总和
          * Min          值最小的元素
          * Max          值最大的元素
          * Average      平均值
          * Aggregate    聚合     可以传递一个lambda表达式，该表达式对有所的值进行聚合
          * 
          * ToArray      转换为数组
          * AsEnumerable 转换为IEnumerable
          * ToList       转换为IList
          * ToDictionary 转换为IDictionary
          * Cast<TResult>
          * 
          * Empty        这些生成操作符返回一个新集合。使用Empty时集合是空的
          * Range        返回一系列数字
          * Repeat       返回一个始终重复一个值的集合；返回一个迭代器，该迭代器把同一个值重复特定的次数。
          * 
          */
            // 1. 查询出 Unity1609 的所有冠军 并按照总分排序
            /*
             * 查询表达式必须以 from 子句开头，以 select 或 group 子句结束。
             * 在这两个子句之间，可以使用 where、oderby、join、let 和其他 from 子句。
             */
            var query = from n in Formula.GetChampions()
                        where n.ClassesName == "Unity1609"
                        orderby n.Sum descending
                        select n;
            // 使用扩展方法实现
            var champions = new List<Student>(Formula.GetChampions());
            IEnumerable<Student> result = champions.Where(o => o.ClassesName == "Unity1609").
            OrderByDescending(o => o.Sum).
            Select(n => n);
            foreach (var item in result)
            {
                Console.WriteLine("{0:N}", item);
            }
            // 2. 筛选 
            // 使用where子句，可以合并多个表达式。
            // 3. 用索引筛选 
            // 不能使用LINQ查询的一个例子是Where()方法的重载。在Where()方法的重载时，可以传递第2个参数-索引。
            // 索引是筛选器返回的每个结果的计数器。
            // 4. 类型筛选 
            // 为了进行基于类型的筛选，可以使用OfType<>()扩展方法。
            object[] data1 = { "one", 2, 3, "four" };
            var query1 = data1.OfType<string>();    // 从集合中仅返回字符串
            // 5. 复合的from子句
            // 如果需要根据对象的一个成员进行筛选，而该成员本身是一个系列，就可以使用复合的from子句。
            // 查询元素是集合的元素  扩展方法 SelectMany() 用于迭代序列的序列
            //var query2 = from r in Formula.GetChampions()
            //from c in r.Scores
            //where c > 90
            //orderby r.Sum
            //select r.Name + " " + r.Sum;
            var query2 = Formula.GetChampions().
            SelectMany(source => source.Scores, (source, collection) => new { Stu = source, Scores = collection }).
            Where(newObj => newObj.Stu.Sum > 90).
            OrderBy(newObj => newObj.Stu.Sum).
            Select(newObj => newObj.Stu.Name + " " + newObj.Stu.Sum);
            // 6. 排序
            // 要对序列排序，前面使用了orderby子句。
            // 7. 分组 
            // 要根据一个关键字值对查询结果分组，可以使用group子句。
            //var query3 = from n in Formula.GetChampions()
            //group n by n.ClassesName into g
            //orderby g.Count(), g.Key
            //where g.Count() >= 2
            //select new
            //{
            //    ClassName = g.Key,
            //    Count = g.Count()
            //};
            // GroupBy()  IGrouping  Key
            var query3 = Formula.GetChampions().
            GroupBy(n => n.ClassesName).
            OrderByDescending(group => group.Count()).
            ThenBy(group => group.Key).
            Where(g => g.Count() >= 2).
            Select(g => new { ClassName = g.Key, Count = g.Count() });
            // 8. 对嵌套的对象分组
            // 如果分组的对象应包含嵌套的序列，就可以改变select子句创建的匿名类型
            var query4 = from r in Formula.GetChampions()
                         group r by r.ClassesName into g
                         orderby g.Count() descending, g.Key
                         where g.Count() >= 2
                         select new
                         {
                             ClassName = g.Key,
                             Count = g.Count(),
                             Scores = from r1 in g
                                      orderby r1.Sum descending, r1.Name
                                      select r1.Scores
                         };
            foreach (var item in query4)
            {
                Console.WriteLine(item.ClassName + " " + item.Count);
            }
            // 9. 内连接 
            // 使用join子句可以根据特定的条件合并两个数据源
            var query5 = from n in Formula.GetChampions()
                         from score in n.Scores
                         select new
                         {
                             Name = n.Name,
                             Score = score,
                             ClassName = n.ClassesName,
                             Years = n.Years
                         };
            var query6 = from n in Formula.GetContructorChampions()
                         from y in n.Years
                         select new
                         {
                             ClassName = n.ClassesName,
                             Year = y
                         };
            var query7 = (from n in query5
                          join t in query6 on n.ClassName equals t.ClassName
                          select new
                          {
                              n.ClassName,
                              n.Name,
                              n.Score,
                              t.Year
                          }).Take(10);
            foreach (var item in query7)
            {
                Console.WriteLine("{0},{1},{2},{3}", item.ClassName, item.Name, item.Score, item.Year);
            }
            // 10. 左外连接  
            // 返回左边序列的全部元素，即时它们在右边的序列中没有匹配的元素
            // 使用 join into、 DefaultIfEmpty 定义 
            var query8 = from n in query5
                         join t in query6 on n.ClassName equals t.ClassName into rt
                         from q in rt.DefaultIfEmpty()
                         orderby n.Score
                         select new
                         {
                             Name = n.Name,
                             ClassName = q == null ? "NoClassName" : n.ClassName,
                             Score = n.Score,
                             Year = q == null ? -1 : q.Year
                         };
            foreach (var item in query8)
            {
                Console.WriteLine($"{item.Name},{item.ClassName},{item.Score},{item.Year}");
            }
            // 11. 组连接 
            // 左外连接使用了组连接和into子句。它有一部分语法与组连接相同。只不过组连接不使用DefaultIfEmpty方法。
            // 使用组连接时，可以连接两个独立的序列，对于其中一个序列中的某个元素，另一个序列中存在对应的一个项列表。
            var query9 = from r in query5
                         from y in r.Years
                         join r2 in query6 on
                         new { ClassName = r.ClassName, Year = y }
                         equals
                         new { ClassName = r2.ClassName, Year = r2.Year }
                         into g
                         select new { ClassName = r.ClassName, Name = r.Name, Year = y, Score = r.Score };
            foreach (var item in query9)
            {
                Console.WriteLine($"{item.ClassName},{item.Name},{item.Score},{item.Year}");
            }
            // 12. 集合操作
            // 扩展方法 Distinct()、Union()、Intersect()和Except() 都是集合操作。
            // 13. 合并
            // Zip()方法允许用一个谓词函数把两个相关的序列合并为一个。
            var query10 = query5.Zip(query6, (first, second) => first.ClassName + "," + first.Name + "," + second.Year);
            // 14. 分区
            // 扩展方法 Take() 和 Skip() 等的分区操作可用于分页。
            // 使用 TakeWhile() 和 SkipWhile() 扩展方法，还可以传递一个谓词，根据谓词的结果提取或跳过某些项。
            // 15. 聚合操作符
            // 聚合操作符（如Count()、Sum()、Min()、Max()、Average()和Aggregate()）不返回一个序列，而返回一个值。
            var query11 = from r in Formula.GetChampions()
                          let scoreCount = r.Scores.Count()        // let子句定义了一个变量
                          where scoreCount >= 2
                          orderby scoreCount descending
                          select new
                          {
                              Name = r.Name,
                              ClassName = r.ClassesName
                          };
            // 16. 转换操作符
            // ToList()
            // Lookup<TKey, TElement>   一个键可以对应多个值
            var query12 = (from r in Formula.GetChampions()
                           from s in r.Scores
                           select new
                           {
                               ClassName = r.ClassesName,
                               Name = r.Name,
                               Score = s
                           }).ToLookup(cr => cr.ClassName, cr => cr.Name);
            foreach (var item in query12["Unity1605"])
            {
                Console.WriteLine($"{item}");
            }
            // 如果需要在非类型化的集合上（如ArrayList）使用LINQ查询，就可以使用Cast()方法。
            var list = new System.Collections.ArrayList(Formula.GetChampions() as System.Collections.ICollection);
            var query13 = from r in list.Cast<Student>()
                          where r.ClassesName == "Unity1605"
                          select r;
            foreach (var item in query13)
            {
                Console.WriteLine($"{item.ClassesName}, {item.Name}");
            }
            // 17. 生成操作符
            // 生成操作符Range()、Empty()和Repeat()不是扩展方法，而是返回序列的正常静态方法。
            //var values = Enumerable.Range(1, 20);   // 第一个参数作为起始值，第二个参数作为要填充的项数
            //values = values.Select(n => n * 3);
            //foreach (var item in values)
            //{
            //    Console.WriteLine(item);
            //}
            // Range()方法不返回填充了所定义值的集合，这个方法与其他方法一样，也推迟执行查询，
            // 并返回一个RangeEnumerator，其中只有一条yield return 语句，来递增值。
            // 18. 并行LINQ
            // System.Linq名称空间中包含的类ParalleEnumerable可以分解查询的工作，使其分布在多个线程上。
            //var res = (from x in SampleData().AsParallel()
            //where Math.Log(x) < 4
            //select x).Average();
            var res = SampleData().AsParallel().Where(x => Math.Log(x) < 4).Select(x => x).Average();
            Console.WriteLine(res);
            // 19. 分区器 
            // AsParalle() 方法不仅扩展了IEnuerable<T> 接口，还扩展了 Partitioner 类。通过它，可以影响要创建的分区。
            // Partitioner 类用 System.Collection.ConCurrent 名称空间定义，并且有不同的变体。
            // Create() 方法接受实现了 IList<T> 类的数组或对象。
            var data = SampleData();
            var res1 = (from x in Partitioner.Create(data).AsParallel()
                        where Math.Log(x) < 4
                        select x).Average();
            Console.WriteLine(res1);
            // 也可以调用 WithExecutionMode() 和 WithDegreeOfParallelism() 方法，来影响并行机制。
            // 20. 取消
            // .NET 提供了一种标准方式，来取消长时间运行的任务，这也适用于并行LINQ
            // 要取消长时间运行的查询，可以给查询添加WithCancellation()方法，并传递一个CancellationToken令牌作为参数。
            // CancellationToken令牌从CancellationTokenSource类中创建。
            // 该查询在单独的线程中运行，在该线程中，捕获一个OperationCanceledException类型的异常。
            // 如果取消了查询，就触发这个异常。在主线程中，调用CancellationTokenSource类的Cancel()方法可以取消任务。
            // 21. 表达式树 Expression<T>
        }
        static IEnumerable<int> SampleData()
        {
            const int arraySize = 100000000;
            var r = new Random();
            return Enumerable.Range(0, arraySize).Select(x => r.Next(140)).ToList();
        }
    }
    #region 扩展方法
    /*
     * 扩展方法 ： 定义为静态方法，其第一个参数定义了它扩展的类型，扩展方法在一个静态类中声明。
     *           为了区分扩展方法和一般的静态方法，扩展方法还需要对第一个参数使用 this 关键字。
     * 
     *           扩展方法不能访问它扩展的类型的私有成员。调用扩展方法只是调用静态方法的一种新语法。
     *           string s = "hello";
     *           s.Foo();
     *           StringExtension.Foo(s);
     */
    public static class StringExtension
    {
        public static void Foo(this string s)
        {
            Console.WriteLine("Foo invoked for {0}", s);
        }
    }
    #endregion
    // 2016~2018年间，所有获得第一名的名单
    static class Formula
    {
        public static List<Student> nameList;
        public static IList<Student> GetChampions()
        {
            if (nameList == null)
            {
                nameList = new List<Student>()
                {
                    new Student("张三", 18, "Unity1605", new int[]{99, 98}, new int[]{2016}),
                    new Student("李四", 20, "Unity1605", new int[]{98, 97}, new int[]{2016}),
                    new Student("李四", 20, "Unity1607", new int[]{98, 97}, new int[]{2016}),
                    new Student("刘五", 21, "Unity1609", new int[]{98, 96}, new int[]{2016}),
                    new Student("王二", 21, "Unity1609", new int[]{99, 96}, new int[]{2016}),
                    new Student("王六", 22, "Unity1609", new int[]{94, 95}, new int[]{2017}),
                    new Student("赵六", 23, "Unity1701", new int[]{96, 96}, new int[]{2017}),
                    new Student("田七", 23, "Unity1711", new int[]{95, 97}, new int[]{2017}),
                    new Student("孙二", 22, "Unity1711", new int[]{94, 98}, new int[]{2018}),
                    new Student("王八", 21, "Unity1801", new int[]{99, 99}, new int[]{2018}),
                    new Student("王八", 21, "Unity1805", new int[]{99, 99}, new int[]{2018}),
                };
            }
            return nameList;
        }
        private static List<ClassesChampion> teams;
        public static IList<ClassesChampion> GetContructorChampions()
        {
            if (teams == null)
            {
                teams = new List<ClassesChampion>()
                {
                    new ClassesChampion("Unity1605", 2016),
                    new ClassesChampion("Unity1607", 2016),
                    new ClassesChampion("Unity1609", 2016, 2017),
                    new ClassesChampion("Unity1701", 2017),
                    new ClassesChampion("Unity1711", 2017, 2018),
                    new ClassesChampion("Unity1801", 2018),
                    new ClassesChampion("Unity1803", 2019)
                };
            }
            return teams;
        }
    }
    // 排行榜 获得第一名学员的班级名字和年份
    class ClassesChampion
    {
        public ClassesChampion(string name, params int[] years)
        {
            this.ClassesName = name;
            this.Years = new List<int>(years);
        }
        public string ClassesName { get; private set; }
        public IEnumerable<int> Years { get; private set; }
    }
    class Student : IComparable<Student>, IFormattable
    {
        public string Name { get; private set; }
        public string ClassesName { get; private set; }
        public int Age { get; set; }
        public int Sum { get; private set; }
        public IEnumerable<int> Scores { get; private set; }
        public IEnumerable<int> Years { get; private set; }        // 获得第一名的年份
        public Student(string name, int age, string classesName) : this(name, age, classesName, null, null) { }
        public Student(string name, int age, string classesName, IEnumerable<int> scores, IEnumerable<int> years)
        {
            this.Name = name;
            this.ClassesName = classesName;
            this.Age = age;
            this.Scores = new List<int>(scores);
            this.Years = new List<int>(years);
            foreach (var item in Scores)
            {
                Sum += item;
            }
        }
        public override string ToString()
        {
            return string.Format("[Student: Name={0}, Age={1}]", Name, Age);
        }
        public string ToString(string format)
        {
            return ToString(format, null);
        }
        public string ToString(string format, IFormatProvider formatProvider)
        {
            switch (format)
            {
                case "N":
                    return this.Name;
                default:
                    return ToString();
            }
        }
        public int CompareTo(Student other)
        {
            if (other == null) return 1;
            return this.Sum - other.Sum;
        }
    }
}

            // Aggregate 用法
            // ---------------------------- 一、对第1个和第2个元素执行操作，将执行的结果继续携带进行操作 ----------------
            // 求1～100的和
            var list = Enumerable.Range(1, 100);
            var sum = list.Aggregate((a, b) => a + b);
            Console.WriteLine(sum);
            // ---------------------------- 二、种子重载 --------------------------------------------------------
            // 先从种子开始作为第一个元素执行操作。
            // 求1～5的阶乘
            var nums = Enumerable.Range(2, 4);  // 2 3 4 5
            var sum1 = nums.Aggregate(1, (a, b) => a * b);
            Console.WriteLine(sum1);
            // 翻转单词
            string content = "i am hxsd";
            content = content.Split(' ').Aggregate((a, b)=> b + " " + a );
            Console.WriteLine(content);
            // --------------------------- 三、结果选择器 --------------------------------------------------------
            // 最长的字符串 输出大写
            string[] fruits = { "apple", "mango", "orange", "passionfruit" };
            string longestName = fruits.Aggregate(fruits[0], (longest, next) => longest.Length < next.Length ? next : longest, n => n.ToUpper());
            Console.WriteLine(longestName);