Linq 常用方法解释

/// <summary>
/// linq
/// </summary>
public class Linq
{
    /// <summary>
    /// 测试
    /// </summary>
    public static void Test()
    {
        Aggregate1();
        Aggregate2();
        Aggregate3();
        All();
        Any();
        Any1();
        Average1();
        Cast();
        Concat();
        Contains();
        DefaultIfEmpty();
        Distinct();
        ElementAt();
        First();
        OrderBy();
        Select();
        SelectMany();
        Skip();
        Where();
    }

    /// <summary>
    /// 对序列应用累加器函数。 
    /// </summary>
    public static void Aggregate1()
    {
        // 1+2+3+4+5
        var numbers = GetArray(5);
        var result = numbers.Aggregate<int>((a, b) => a + b);
        Console.WriteLine("和为:{0}", result);
        /*
         * Aggregate 接收一个 Func<TSource, TSource, TSource> func 参数
         * 要对每个元素调用的累加器函数
         * 累加器的最终值
         * 所以1-5的最终累加结果为15
         * 如果在1-5累加的时候 需要首先加个5怎么办 见 Aggregate2()
         */
    }

    /// <summary>
    ///  对序列应用累加器函数。 将指定的种子值用作累加器初始值。 
    /// </summary>
    public static void Aggregate2()
    {
        // 1+2+3+4+5
        var numbers = GetArray(5);
        var result = numbers.Aggregate<int, int>(5, (a, b) => a + b);
        Console.WriteLine("和为:{0}", result);
        /*
         * Aggregate 接收2个参数 TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func
         * seed 累加器的初始值
         * func 要对每个元素调用的累加器函数
         * 累加器的最终值
         * 所以1-5的最终累加结果为20 因为累加的初始值是5
         * 如果要对最终结果 在-2 怎么处理呢 Aggregate3()
         */
    }

    /// <summary>
    ///  对序列应用累加器函数。 将指定的种子值用作累加器初始值。 
    /// </summary>
    public static void Aggregate3()
    {
        // 1+2+3+4+5
        var numbers = GetArray(5);
        var result = numbers.Aggregate<int, int, int>(5, (a, b) => a + b, rel => rel - 2);
        Console.WriteLine("和为:{0}", result);
        /*
         * Aggregate 接收3个参数 TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector
         * seed 累加器的初始值
         * func 要对每个元素调用的累加器函数
         * resultSelector 结果处理
         * 累加器的最终值
         * 所以1-5的最终累加结果为18 因为累加的初始值是5 并且最终几个会 -2
         * 
         */
    }

    /// <summary>
    /// 确定序列中的所有元素是否满足条件
    /// </summary>
    public static void All()
    {
        var list = Book.Books;

        // 这个集合中是否 所有的页数都大于200页 如果都大于则返回true否则返回 false
        var result = list.All(item => item.PageCount > 100);
    }

    /// <summary>
    /// 确定序列是否包含任何元素
    /// </summary>
    public static void Any()
    {
        var list = Book.Books;

        // 这个集合是否有元素 如果存在则有true 否则 返回false
        var result = list.Any();
    }

    /// <summary>
    /// 确定序列是否包含任何元素
    /// </summary>
    public static void Any1()
    {
        var list = Book.Books;

        // 这个集合中是否 包含的页数大于200页的元素 如果包含则返回true否则返回 false
        var result = list.Any(item => item.PageCount > 200);
    }

    /// <summary>
    /// 计算可以为 null 的 System.Decimal 值序列的平均值。
    /// </summary>
    public static void Average1()
    {
        var numbers = GetArray(5);

        // 平均值
        var result = numbers.Average();

        // 最大值
        var rel = numbers.Max();

        // 最小值
        var rel1 = numbers.Min();

        // 求和
        var rel2 = numbers.Sum();

        var list = Book.Books;
    }

    /// <summary>
    /// 计算序列的平均值。
    /// </summary>
    public static void Average2()
    {
        var list = Book.Books;

        // 求平均页数
        var result = list.Average(item => item.PageCount);
    }

    /// <summary>
    /// 将 System.Collections.IEnumerable 的元素强制转换为指定的类型
    /// </summary>
    public static void Cast()
    {
        // 首先创建一个以前版本的集合
        ArrayList arraylist = new ArrayList();

        // 原本希望在这里初始化，但是这个初始化功能不支持以前的版本
        arraylist.Add("111");
        arraylist.Add("222333");
        arraylist.Add("333333333");
        arraylist.Add("xxxxxxxxx");

        // 数据类型不一直的时候 Cast会抛出异常OfType 则会返回一个空序列 
        // IEnumerable<int> lists = arraylist.Cast<int>();
        IEnumerable<int> lists = arraylist.OfType<int>();
        foreach (int list in lists)
        {
            Console.WriteLine(list);
        }
    }

    /*Concat/Union/Intersect/Except操作*/
    /*
     * 连接操作
     * Concat  :连连接两个序列
     * Union  : 通过使用默认的相等比较器生成两个序列的并集
     * Intersect : 通过使用默认的相等比较器对值进行比较生成两个序列的交集
     * Except : 排除相交项；延迟。即是从某集合中删除与另一个集合中相同的项。先遍历第一个集合，找出所有唯一的元素，然后再遍历第二个集合，返回第二个集合中所有未出现在前面所得元素集合中的元素
     */

    /// <summary>
    /// 连连接两个序列
    /// </summary>
    public static void Concat()
    {
        // 假设有两序列：
        var a = new List<int> { 1, 1, 2, 3, 4 };
        var b = new List<int> { 4, 5, 5, 6, 7 };
        /*
         * 那么A.Concat(B) 表示将A序列和B序列串联起来，以创建新的序列，不去除重复部分;
         * A.Union(B)表示将A序列和B序列串联起来，并去除重复部分，以创建新的序列;
         * 而A.Intersect(B) 只取A序列和B序列相同的部分(交集)，以创建新的序列。
         * Except则是差集
         */
        var concat = a.Concat(b).ToList();
        var union = a.Union(b).ToList();
        var intersect = a.Intersect(b).ToList();
        var except = a.Except(b).ToList();
    }

    /// <summary>
    /// 通过使用默认的相等比较器确定序列是否包含指定的元素
    /// </summary>
    public static void Contains()
    {
        IEnumerable<int> a = new List<int> { 1, 1, 2, 3, 4 };

        // 序列是否包含 元素3
        bool rel = a.Contains(3);

        var list = Book.Books;

        // 使用自定义比较器
        bool rel1 = list.Contains(new Book { Title = "C#" }, new BookEqualityComparer());
    }

    /// <summary>
    /// 返回序列中的元素数量。
    /// </summary>
    public static void Count()
    {
        var list = Book.Books;
        var count = list.Count();
        var count1 = list.Count(item => item.Title == "C#");
    }

    /// <summary>
    /// 返回指定序列的元素；如果序列为空，则返回单一实例集合中的类型参数的默认值。
    /// </summary>
    public static void DefaultIfEmpty()
    {
        IEnumerable<Book> list = new List<Book>();
        var rek = list.DefaultIfEmpty();
        var rek1 = list.DefaultIfEmpty(new Book { Title = "VV" });
    }

    /// <summary>
    /// 去除重复
    /// </summary>
    public static void Distinct()
    {
        IEnumerable<int> a = new List<int> { 1, 1, 2, 3, 4 };
        var rel = a.Distinct();
    }

    /// <summary>
    /// 返回序列中指定索引处的元素。
    /// </summary>
    public static void ElementAt()
    {
        IEnumerable<int> a = new List<int> { 1, 1, 2, 3, 4 };

        // 返回索引为3的元素
        var rel = a.ElementAt(3);

        // 返回序列中指定索引处的元素；如果索引超出范围，则返回默认值。
        // int类型的默认值 则为0
        var rel1 = a.ElementAtOrDefault(50);
    }

    /// <summary>
    /// 返回元素第一个元素
    /// </summary>
    public static void First()
    {
        var a = Book.Books;

        // 返回第一个元素 没有元素则报错
        var r1 = a.First();

        // 返回第一个元素 没有元素则返回默认值
        var r2 = a.FirstOrDefault();

        // 返回序列的唯一元素；如果该序列并非恰好包含一个元素，则会引发异常
        // var r3 = a.Single();

        // 返回序列中的唯一元素；如果该序列为空，则返回默认值；如果该序列包含多个元素，此方法将引发异常。
        // var r4 = a.SingleOrDefault();

        // 返回最后一个元素 没有元素则报错
        var r5 = a.Last();

        // 返回最后一个元素 没有元素则返回默认值
        var r6 = a.LastOrDefault();
    }

    /// <summary>
    /// 分组
    /// </summary>
    public static void GroupBy()
    {
        var list = Book.Books;

        // 计数
        var q = from p in list
                group p by p.Title into g
                select new
                {
                    g.Key,
                    NumProducts = g.Count()
                };

        // 带条件计数
        var q1 = from p in list
                 group p by p.Title into g
                 select new
                 {
                     g.Key,
                     NumProducts = g.Count(p => p.PageCount > 200)
                 };

        // Where限制
        var q2 = from p in list
                 group p by p.Title into g
                 where g.Count() >= 10
                 select new
                 {
                     g.Key,
                     NumProducts = g.Count(p => p.PageCount > 200)
                 };

        // 多列(Multiple Columns)
        var categories = from p in list group p by new { p.Title, p.PageCount } into g select new { g.Key, g };

        // 表达式(Expression)
        var categories1 = from p in list group p by new { Criterion = p.PageCount > 10 } into g select g;
    }

    /// <summary>
    /// 排序
    /// </summary>
    public static void OrderBy()
    {
        var list = Book.Books;

        // 根据页码升序
        var rel1 = list.OrderBy(o => o.PageCount);

        // 根据页码+标题升序
        var rel11 = list.OrderBy(o => o.PageCount).ThenBy(o => o.Title);

        // 根据页码降序
        var rel2 = list.OrderByDescending(o => o.PageCount);

        // 根据页码+标题降序
        var rel22 = list.OrderByDescending(o => o.PageCount).ThenByDescending(o => o.Title);

        // 根据标题的长度升序 排序
        var rel = list.OrderBy(o => o.Title, new BookComparer()).ToList();
    }

    /// <summary>
    /// 投影
    /// </summary>
    public static void Select()
    {
        var list = Book.Books;

        // 投影一个新的集合
        var select = list.Select(item => new { T = item.Title });

        // 投影一个待索引的集合
        var select1 = list.Select((item, index) => new { I = index });
    }

    /// <summary>
    /// 将序列的每个元素投影并将结果序列合并为一个序列。
    /// </summary>
    public static void SelectMany()
    {
        /*
         * 类School下面有一个Class的集合，每个Class下面有有一个Student的集合。每个学生有Name和Sex两个属性。现在需要遍历School下面的所有的学生，当然我们可以用两个嵌套的foreach语句类遍历School下面的所有的Class，然后再用foreach来遍历Class下面的所有的Student，把他们添加到一个List里去。这个场景也是实际编程中经常遇到的。有了Linq我们就可以大大的简化我们的代码：
         */

        // 初始化数据  
        School s = new School();
        for (int i = 0; i < 5; i++)
        {
            s.Classes.Add(new Class());
        }
        s.Classes[0].Students.Add(new Student(1, "a0"));
        s.Classes[1].Students.Add(new Student(1, "b0"));
        s.Classes[2].Students.Add(new Student(0, "c0"));
        s.Classes[3].Students.Add(new Student(0, "d0"));
        s.Classes[4].Students.Add(new Student(0, "e0"));
        s.Classes[0].Students.Add(new Student(0, "a1"));
        s.Classes[0].Students.Add(new Student(1, "a1"));
        s.Classes[0].Students.Add(new Student(1, "a2"));
        s.Classes[0].Students.Add(new Student(1, "a3"));
        s.Classes[1].Students.Add(new Student(0, "b1"));
        s.Classes[2].Students.Add(new Student(0, "c1"));
        s.Classes[3].Students.Add(new Student(0, "d1"));

        // 取出school下的所有性别是0的student  
        var x = s.Classes.SelectMany(b => b.Students).Where(i => i.Sex == 0);
        foreach (var b in x)
        {
            Console.WriteLine(b.Name);
        }

        // 合并
        var x1 = s.Classes.SelectMany(b => b.Students, (a, c) => new { a.Students.Count, c.Name });
    }

    /// <summary>
    ///  跳过序列中指定数量的元素，然后返回剩余的元素。
    /// </summary>
    public static void Skip()
    {
        var list = Book.Books;

        // 跳高前2个元素
        var rel = list.Skip(2);

        // 只要满足指定的条件，就跳过序列中的元素，然后返回剩余元素。
        var rel1 = list.SkipWhile(iem => iem.PageCount < 2000).ToList();

        // 返回前2个元素
        var rel2 = list.Take(2);

        // 只要满足指定的条件，就会返回序列的元素。
        var rel3 = list.TakeWhile(w => w.PageCount < 2000).ToList();
    }

    /// <summary>
    /// 查询
    /// </summary>
    public static void Where()
    {
        var list = Book.Books;

        // 页码大于2000页的
        var rel = list.Where(w => w.PageCount > 2000);

        // 页码大于2000页的 并且索引大于2
        var rel1 = list.Where((a, b) => a.PageCount > 2000 && b > 2);
    }

    /// <summary>
    /// 比较器
    /// </summary>
    public class BookComparer : IComparer<string>
    {
        /// <summary>
        /// 实现
        /// </summary>
        /// <param name="x">x</param>
        /// <param name="y">y</param>
        /// <returns>一个有符号整数，指示 x 与 y 的相对值，如下表所示。 值 含义 小于零 x 小于 y。 零 x 等于 y。 大于零 x 大于 y</returns>
        public int Compare(string x, string y)
        {
            if (x.Length > y.Length)
            {
                return 1;
            }
            else if (x.Length < y.Length)
            {
                return -1;
            }

            return 0;
        }
    }

    /// <summary>
    /// 书籍比较器
    /// </summary>
    public class BookEqualityComparer : IEqualityComparer<Book>
    {
        /// <summary>
        /// 比较器
        /// </summary>
        /// <param name="x">x</param>
        /// <param name="y">y</param>
        /// <returns>结果</returns>
        public bool Equals(Book x, Book y)
        {
            return x.Title == y.Title;
        }

        /// <summary>
        /// GetHashCode
        /// </summary>
        /// <param name="obj">obj</param>
        /// <returns>HashCode</returns>
        public int GetHashCode(Book obj)
        {
            return obj.Title.GetHashCode();
        }
    }

    /// <summary>
    /// 获取一个值的集合
    /// </summary>
    /// <param name="max">最大值</param>
    /// <returns>一个值的集合</returns>
    public static IEnumerable<int> GetArray(int max)
    {
        List<int> result = new List<int>(max);
        for (int i = 0; i < max; i++)
        {
            result.Add(i + 1);
        }
        return result;
    }

    /// <summary>
    /// 书籍
    /// </summary>
    public class Book
    {
        /// <summary>
        /// 标题
        /// </summary>
        public string Title { get; set; }

        /// <summary>
        /// 页数
        /// </summary>
        public int PageCount { get; set; }

        /// <summary>
        /// 默认的书籍集合
        /// </summary>
        public static IEnumerable<Book> Books
        {
            get
            {
                return new List<Book>
                           {
                               new Book { Title = "C#", PageCount = 1200 },
                               new Book { Title = "MVC", PageCount = 2200 },
                               new Book { Title = "ASP.NET", PageCount = 12200 },
                               new Book { Title = "java", PageCount = 1500 },
                               new Book { Title = "jquery", PageCount = 2140 },
                           };
            }
        }
    }

    /// <summary>
    /// 学校
    /// </summary>
    public class School
    {
        /// <summary>
        /// m_Classes
        /// </summary>
        private IList<Class> classes = new List<Class>();

        /// <summary>
        /// Classes
        /// </summary>
        internal IList<Class> Classes
        {
            get { return this.classes; }
            set { this.classes = value; }
        }
    }

    /// <summary>
    /// class
    /// </summary>
    public class Class
    {
        /// <summary>
        /// m_Students
        /// </summary>
        private IList<Student> students = new List<Student>();

        /// <summary>
        /// Students
        /// </summary>
        internal IList<Student> Students
        {
            get { return this.students; }
            set { this.students = value; }
        }
    }

    /// <summary>
    /// 学生
    /// </summary>
    public class Student
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Student"/> class.
        /// </summary>
        /// <param name="i">
        /// The i.
        /// </param>
        /// <param name="name">
        /// The name.
        /// </param>
        public Student(int i, string name)
        {
            this.Sex = i;
            this.Name = name;
        }

        /// <summary>
        /// 姓名
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 性别
        /// </summary>
        public int Sex { get; set; }
    }
}