Linq知识集三（翻译）

2022-03-30

字数统计: 1.9k字 | 阅读时长≈ 10分

原文起始连接：https://dotnettutorials.net/course/linq/

说明：翻译接上篇，后面的内容基本是介绍Linq的操作符对应的方法，这部分如果有SQL编程基础的，部分内容将会很容易理解。有些地方我就简化，只提供原文中一些实例，不做过多翻译解释内容了。

LINQ中的排序操作符

排序操作对标SQL中的Order By，LINQ中提供了一系列方法提供排序使用。类似与SQL，默认升序（即Order By后面不加关键字的话，就默认ASC排序）

OrderBy 使用升序排序
OrderByDescending 使用降序排序
ThenBy 多个字段排序，从第二个开始使用ThenBy
ThenByDescending 多个字段排序，从第二个开始使用ThenBy(逆序排列)
Reverse 将序列倒叙

下面来一个综合例子展示几个方法的使用

 public class Student
    {
        public int ID { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Branch { get; set; }
        public static List<Student> GetAllStudents()
        {
            List<Student> listStudents = new List<Student>()
            {
                new Student{ID= 101,FirstName = "Preety",LastName = "Tiwary",Branch = "CSE"},
                new Student{ID= 102,FirstName = "Preety",LastName = "Agrawal",Branch = "ETC"},
                new Student{ID= 103,FirstName = "Priyanka",LastName = "Dewangan",Branch = "ETC"},
                new Student{ID= 104,FirstName = "Hina",LastName = "Sharma",Branch = "ETC"},
                new Student{ID= 105,FirstName = "Anugrag",LastName = "Mohanty",Branch = "CSE"},
                new Student{ID= 106,FirstName = "Anurag",LastName = "Sharma",Branch = "CSE"},
                new Student{ID= 107,FirstName = "Pranaya",LastName = "Kumar",Branch = "CSE"},
                new Student{ID= 108,FirstName = "Manoj",LastName = "Kumar",Branch = "ETC"},
                new Student{ID= 109,FirstName = "Pranaya",LastName = "Rout",Branch = "ETC"},
                new Student{ID= 110,FirstName = "Saurav",LastName = "Rout",Branch = "CSE"}
            };
            return listStudents;
        }
    }

//   var MS = Student.GetAllStudents().OrderBy(x => x.Branch).ToList();
var orderBy = Student.GetAllStudents().OrderBy(x => x.Branch).ToList();
var orderByDescending = (from stu in Student.GetAllStudents()
                        select stu).OrderBy(stu => stu.Branch);
var thenBy = Student.GetAllStudents().OrderBy(x => x.Branch).ThenBy(y => y.FirstName);
var thenByDescending = (from stu in Student.GetAllStudents()
                        where stu.Branch == "CSE"
                        orderby stu.FirstName,
                        stu.LastName descending
                        select stu);

List<string> stringList = new List<string>() { "Preety", "Tiwary", "Agrawal", "Priyanka", "Dewangan" };

IEnumerable<string> ReverseData1 = stringList.AsEnumerable().Reverse();
IQueryable<string> ReverseData2 = stringList.AsQueryable().Reverse();

LINQ中的聚合操作

Aggregate聚合操作顾名思义是将序列按规则聚合成一个值，比如求和、求平均、求最大最下等。LINQ中提供以下方法实现聚合

SUM
MAX
MIN
Average
Count
Aggregate

前几个方法比较简单，类似于SQL中的聚合函数。下面举例展示用法

List<int> intList = new List<int>{10,45,35,29,100,69,58,50};
int sum = intList.Sum(num => {
    if(num > 50)
        return num;
    else
        return 0;
});
int max = (from num in intList
        select num).Max();
int min = intList
        .Where(num => num > 20)
        .Min();
double average = (from num in intList
            select num).Average();

int studentCount = Student.GetAllStudents().Count();
Console.WriteLine($"Sum: {sum}  Max: {max}  Min: {min}  Average: {average}");

重点看看Aggregate方法的签名

1
2
3

public static TSource Aggregate<TSource>(this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func);
public static TAccumulate Aggreate<TSource, TAccumulate>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func);
public static TResult Aggregate<TSource, TAccumulate, TResult>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector);

举个例子看看用法

string[] skills = { "C#.NET", "MVC", "WCF", "SQL", "LINQ", "ASP.NET" };
string result = skills.Aggregate((s1, s2) => s1 + ", " + s2);

//下面的例子展示复杂类的处理

 int Salary = Employee.GetAllEmployees()
                    .Aggregate<Employee, int>(0,
                    (TotalSalary, emp) => TotalSalary += emp.Salary);


public class Employee
{
    public int ID { get; set; }
    public string Name { get; set; }
    public int Salary { get; set; }
    public string Department { get; set; }
    public static List<Employee> GetAllEmployees()
    {
        List<Employee> listStudents = new List<Employee>()
        {
            new Employee{ID= 101,Name = "Preety", Salary = 10000, Department = "IT"},
            new Employee{ID= 102,Name = "Priyanka", Salary = 15000, Department = "Sales"},
            new Employee{ID= 103,Name = "James", Salary = 50000, Department = "Sales"},
            new Employee{ID= 104,Name = "Hina", Salary = 20000, Department = "IT"},
            new Employee{ID= 105,Name = "Anurag", Salary = 30000, Department = "IT"},
            
        };
        return listStudents;
    }
}

LINQ中的量化操作

量化操作用于检查数据源中是否部分或所有元素都满足一定条件。因此我们需要一个数据源，需要一个输入条件，返回bool值，表示数据源中的元素是否满足输入条件。LINQ中提供下面几个量化操作方法。

All 是否所有元素满足给定条件
Any 是否至少一个元素满足条件
Contains 检查数据源是否包含某特定元素

下面例子展示如何使用这些方法

string[] stringArray = { "James", "Sachin", "Sourav", "Pam", "Sara" };
bool allResult = stringArray.All(name => name.Length > 5);
bool anyResult = stringArray.Any(name => name.Length > 5);
bool containsResult = stringArray.Contains("Pam");
Console.WriteLine($"all: {allResult}  any:{anyResult}  contains:{containsResult}");

LINQ中的分组

GroupBy

分组操作和SQL中的Group By语句一样，LINQ中提供GroupBy方法来实现，它返回IEnumerable<IGrouping<TKey,TSource>>。参数中TSource表示集合中的元素，TKey表示分组使用的键。

var GroupMS = Student.GetStudents.GroupBy(s=>s.Branch);
IEnumerable<IGrouping<string, Student>> GroupQS = (from stu in Student.GetStudents()
                                                    group stu by stu.Branch);

var GroupKeyQs = from stu in Student.GetStudents()
                group stu by stu.Gender into stuGroup
                orderby stuGroup.Key descending
                select new
                {
                    Key = stuGroup.Key,
                    Students = stuGroup.OrderBy(x => x.Name)
                };


  public class Student
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public string Gender { get; set; }
        public string Barnch { get; set; }
        public int Age { get; set; }
        public static List<Student> GetStudents()
        {
            return new List<Student>()
        {
            new Student { ID = 1001, Name = "Preety", Gender = "Female",
                                         Branch = "CSE", Age = 20 },
            new Student { ID = 1002, Name = "Snurag", Gender = "Male",
                                         Branch = "ETC", Age = 21  },
            new Student { ID = 1003, Name = "Pranaya", Gender = "Male",
                                         Branch = "CSE", Age = 21  },
            new Student { ID = 1004, Name = "Anurag", Gender = "Male",
                                         Branch = "CSE", Age = 20  },
            new Student { ID = 1005, Name = "Hina", Gender = "Female",
                                         Branch = "ETC", Age = 20 },
            new Student { ID = 1006, Name = "Priyanka", Gender = "Female",
                                         Branch = "CSE", Age = 21 },
            new Student { ID = 1007, Name = "santosh", Gender = "Male",
                                         Branch = "CSE", Age = 22  },
            new Student { ID = 1008, Name = "Tina", Gender = "Female",
                                         Branch = "CSE", Age = 20  },
            new Student { ID = 1009, Name = "Celina", Gender = "Female",
                                         Branch = "ETC", Age = 22 },
            new Student { ID = 1010, Name = "Sambit", Gender = "Male",
                                         Branch = "ETC", Age = 21 }
        };
        }
    }

如果需要使用多字段进行分组时，使用GroupBy方法。将多字段组织成一个匿名类对象，下面仍然使用上面的学生数据源，使用Branch和Gender两个字段进行分组。

var groupMultipleKeysMS = Student.GetAllStudents()
                        .GroupBy(x => new {x.Branch, x.Gender})
                        .OrderByDescending(g => g.Key.Branch)
                        .ThenBy(g => g.Key.Gender)
                        .Select(g => new 
                        {
                            Branch = g.Key.Branch,
                            Gender = g.Key.Gender,
                            Students = g.OrderBy(x => x.Name)
                        });
var groupMultipleKeysQS = from student in Student.GetStudents()
                        group student by new
                        {
                            student.Branch,
                            student.Gender
                        } into stuGroup
                        orderby stuGroup.Key.Branch descending,
                                stuGroup.Key.Gender ascending
                        select new
                        {
                            Branch = stuGroup.Key.Branch,
                            Gender = stuGroup.Key.Gender,
                            Students = stuGroup.OrderBy(x => x.Name)
                        };

ToLookUp

ToLookUp和GroupBy实现的功能一样，都是用于分组。而两者的区别则是，GroupBy延迟执行，而ToLookup则是实时执行的。对比下面两个查询，groupMS查询使用的GroupBy分组，如果我们把.ToList()去掉，输出结果则得不到我们期望的。对于延迟加载的，可以通过调用.ToList()方法立即执行。

var groupMS = Student.GetAllStudents().GroupBy(s => s.Gender)
            .OrderByDescending(c => c.Key)
            .Select(stu => new {
                Key = stu.Key,
                Students = stu.OrderBy(x => x.Name)
            }).ToList();

var lookupByMS = Student.GetStudents().ToLookup(s => s.Gender)
                .OrderByDescending(c => c.Key)
                .Select(stu => new {
                    Key = stu.Key,
                    Students = stu.OrderBy(x => x.Name)
                });

本文作者： 达文西
本文链接： https://edsiongithub.github.io/2022/03/30/32/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！