C#的lambda表达式与Linq

C#的lambda表达式、Linq、以及常用方法

Lambda：简单来讲就是匿名函数，我们不声明方法名，只写一个方法体，这个方法体就是lambda表达式

Linq：Linq是 Language Intergrated Query（语言集成查询）的缩写，可以对本地对象**集合**或者远程数据源进行结构化的查询操作。

lambda表达式

如何写一个lambda表达式

首先，在写lambda表达式之前，需要先了解 两个特殊的类型：Func和Action。

这是两个委托，这里先不急着了解什么是委托（详细讲解请查看：C# 委托 与 事件_c# 事件与委托-优快云博客），可以把它们当做一种名称规范就行，它们都可以表示一个方法。不同的是其中Func表示一个有返回值的方法，Action表示一个没有返回值的方法。C#对这两个的定义如下：

public delegate TResult Func<out TResult>();//注意这里的out 表示这个泛型是返回值的类型泛型
public delegate void Action();

其中Func和Action各有16个变种：

// 注意 in 关键字，表示泛型是参数的类型约束
public delegate TResult Func<in T,out TResult>(T arg);
public delegate TResult Func<in T1,in T2,out TResult>(T1 arg1, T2 arg2);
……
public delegate TResult Func<in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,in T12,in T13,in T14,in T15,in T16,out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);
//
//

public delegate void Action<in T>(T obj);
public delegate void Action<in T1,in T2>(T1 arg1, T2 arg2);
……
public delegate void Action<in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8,in T9,in T10,in T11,in T12,in T13,in T14,in T15,in T16>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);

依次表示一个参数、两个参数、……十六个参数 的方法。当然，你还可以写更多的参数，但是如果一个方法的参数超过10个，为什么不用类封装起来呢？即使不封装，一个方法十几个参数，你确定不会被你的领导嫌弃吗。

言归正传，介绍完了Func和Action的定义，那么如果使用呢？

public void Demo1()
{
    // 一个没有返回值，也没有参数的方法
}

Action act1 = Demo;// 直接给一个方法名

public void Demo2(string name)
{
    //有一个参数，但没有返回值的方法
}

Action<string> act2 = Demo2;

public String Demo3()
{
    // 有返回值，但没有参数的方法
}
Func<string> func1 = Demo3;

public int Demo4(double data)
{
    // 返回值是int，有一个参数是double的方法
}

Func<double,int> func2 = Demo4;

以上是通过方法名获取Func和Action的方法，下面介绍一下通过Lambda表达式的方式创建Func和Action：

Action act1 = ()=> // lambda 的标志性 声明方式 =>
{
	// 这是一个没有返回值，也没有参数的 lambda表达式
};
Action<int> act2 = (age) => 
{
    // 这是一个 参数为int ，没有返回值的 lambda表达式
};
//=========================================
Func<string> func1 = () => ""; // 这是一个返回了空字符串的lambda表达式，注意这种写法
Func<string> func2 = () =>
{
    return ""; //与上一个等价
}

Func<int,string> func3 = (age) =>
{
    return "我的年纪是："+age;// 一个参数是int，返回类型是string的lambda表达式
}

在lambda表达式中，当使用的是有返回值的方法体时，如果方法体是个简单的计算式或者说可以在一行内写完（或被编译器认为是一行）的话，可以省略 {、} 和return，直接用 => 标记。

比如说以下内容：

Func<int,int,int> cal_area = (width, height) => width * height;// 计算面积

使用Lambda 表达式

现在我们手里有一大堆的Action和Func，我们该怎么用呢？

有以下两种常见的用法：

1. 把它当做方法来用：

// 上接上文代码
act1();// 执行 act1 代表的方法或lambda表达式
act2(10); //执行act2 的lambda表达式

string str1 = func1();
string str2 = func3(10);
int area = cal_area(29,39);

1. 调用Invoke方法：

act1.Invoke();
act2.Invoke(10);

area = cal_area.Invoke(33,63);

看过反射篇的应该对Invoke有一定印象，这个与MethodInfo里的Invoke类似，但是比其更加简单。

Linq 是什么

正如前言所述，Linq是一种对集合、数据源的集成式查询方式，它是对IEnumerable<T>的扩展方法集，所以想要使用Linq的话，需要引用两个命名空间 System.Linq和System.Linq.Expressions。

Linq有两种使用方式，一种是通过方法链的方式调用，一种是类似SQL语句的方式进行数据查询。方法链是基础，类SQL方式是语法糖。下面简单介绍一下两种方式的使用，不过首先先假设我们有一个数据很多的集合：

IEnumerable<int> scores = new List<int>();//假设存放了某班50个人的语文成绩

使用方法链查询

1. 获取分数大于60的所有分数：

csharp
   IEnumerable<int> result1 = scores.Where(t => t > 60);

1. 获取分数大于等于60的数量：

csharp
   int count = scores.Count(t => t >= 60);

1. 统计分数总和

csharp
   int sum = scores.Sum();

1. 获取所有分数个位上的数字：

csharp
   IEnumerable<int> result2 = scores.Select(t => t % 10);

使用类SQL形式查询

查询所有大于等于60的分数:

IEnumerable<int> result3 = from score in scores
                where score >= 60
                select score;

简单介绍一下，类SQL形式有一个统一的格式写法，关键字from、in、select缺一不可：

from 临时变量名 in 数据源

select 结果类型

where 是条件过滤，如果查询全部，可以忽略。

这种方式之所以被我称为是类SQL形式，是因为它的写法和SQL及其相似，熟悉SQL的可以很快上手。

为什么说方法链是基础呢？

因为SQL形式的查询里每一个关键字背后都有一个方法作为支撑，除了from 和in。

select 对应的Select 方法，where对应的Where方法。

需要特别注意的一点：

Linq查询是一种延迟查询，也就是说当返回类型是一个IEnumerable 的时候不会立即返回结果，必须调用ToList才能获取到实际查询结果。另外需要注意的是，ToList返回的是一个不可变List集合

前置概念介绍

1. Predicate<T> 谓词、断言，等价于 Func<T,bool> 即返回bool的表达式
2. Expression<TDelegate> 表达式树，这个类很关键，但是在这里会细说，我们会讲它的一个特殊的泛型类型：Expression<Func<T,bool>> 这个在某些数据源的查询中十分重要，它代表lambda表达式中一种特殊的表达式，即没有大括号和return关键字的那种。

我们先准备两个类：

1. Student/学生类：

   /// <summary>
   /// 学生
   /// </summary>
   public class Student
   {
       /// <summary>
       /// 学号
       /// </summary>
       public int StudentId { get; set; }
       /// <summary>
       /// 姓名
       /// </summary>
       public string Name { get; set; }
       /// <summary>
       /// 班级
       /// </summary>
       public string Class { get; set; }
       /// <summary>
       /// 年龄
       /// </summary>
       public int Age { get; set; }
   }

1. Subject/科目类：

   /// <summary>
   /// 科目
   /// </summary>
   public class Subject
   {
       /// <summary>
       /// 名称
       /// </summary>
       public string Name { get; set; }
       /// <summary>
       /// 年级
       /// </summary>
       public string Grade { get; set; }
       /// <summary>
       /// 学号
       /// </summary>
       public int StudentId { get; set; }
       /// <summary>
       /// 成绩
       /// </summary>
       public int Score { get; set; }
   }

Subject 和Student通过学号字段一一关联，实际工作中数据表有可能会设计成这。

那么先虚拟两个数据源：IEnumerable<Student> students 和 IEnumerable<Subject> subjects。先忽略这两个数据源的实际来源，因为在开发过程中数据来源有很多种情况，有数据库查询出来的结果、远程接口返回的结果、文件读取的结果等等。不过最后都会整理成IEnumerable<T>的子接口或实现类的对象。

常见方法介绍

Where 过滤数据，查询出符合条件的结果

where的方法声明：

public IEnumerable<TSource> Where<TSource> (this IEnumerable<TSource> source, Func<TSource,bool> predicate)

可以看出不会转换数据类型，通过给定的lambda表达式或者一个方法进行过滤，获取返回true的元素。

示例：

// 获取年纪大于10但不大于12的同学们
List<Student> results = students.Where(t=>t.Age >10 && t.Age<= 12).ToList();

注意在调用ToList之后数据才会实质上查询出来。

Group 分组，依照指定内容进行分组

Group的方法声明有很多种：

最常用的一种是：

public static IEnumerable<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey> (this IEnumerable<TSource> source, Func<TSource,TKey> keySelector);

示例：

//将学生按照班级进行分组
List<IGrouping<string,Student>> list = students.GroupBy(p => p.Class).ToList();

OrderBy/OrderByDescending 进行排序，按条件升序/降序

它们是一对方法，一个是升序一个降序，其声明是一样的：

常用的是：

public static System.Linq.IOrderedEnumerable<TSource> OrderBy<TSource,TKey> (this IEnumerable<TSource> source, Func<TSource,TKey> keySelector);

示例：

//按年龄的升序排列：
List<Student> results = students.OrderBy(p => p.Age).ToList();
//按年龄的降序排列：
List<Student> results = students.OrderByDescending(p => p.Age).ToList();

First/Last 获取数据源的第一个/最后一个

这组方法有两个常用的重载声明：

First：

// 直接获取第一个
public static TSource First<TSource> (this IEnumerable<TSource> source);
// 获取满足条件的第一个
public static TSource First<TSource> (this IEnumerable<TSource> source, Func<TSource,bool> predicate);

Last：

// 直接获取最后一个
public static TSource Last<TSource> (this IEnumerable<TSource> source);
// 获取最后一个满足条件的元素
public static TSource Last<TSource> (this IEnumerable<TSource> source, Func<TSource,bool> predicate);

示例：

Student student = students.First();// 等价于 students[0];
Student student = students.First(p=>p.Class == "一班");//获取数据源中第一个一班的同学

Student student = students.Last();//最后一个学生
Student student = students.Last(p=>p.Class == "三班");//获取数据源中最后一个三班的同学

注意：

• 在某些数据源中使用Last会报错，因为对于一些管道类型的数据源或者说异步数据源，程序无法确认最后一个元素的位置，所以会报错。解决方案：先使用OrderBy对数据源进行一次排序，使结果与原有顺序相反，然后使用First获取
• 当数据源为空，或者不存在满足条件的元素时，调用这组方法会报错。解决方案：调用FirstOrDefault/LastOrDefault，这两组方法在无法查询到结果时会返回一个默认值。

Any/All 是否存在/是否都满足

Any：是否存在元素满足条件

有两个版本，不过意思可能不太一样：

public static bool Any<TSource> (this IEnumerable<TSource> source);//数据源中是否有数据
//================
//是否存在满足条件的数据
public static bool Any<TSource> (this IEnumerable<TSource> source, Func<TSource,bool> predicate);

All ：是否都满足条件：

public static bool Any<TSource> (this IEnumerable<TSource> source, Func<TSource,bool> predicate);

示例：

// 是否有学生
bool isAny =  students.Any();
// 是否有五班的同学
bool isFive = students.Any(p=>p.Class == "五班");
// 是否所有学生的年纪都不小于9岁
bool isAll = students.All(p=>p.Age >= 9);

Skip 略过几个元素

Skip一共有三个衍生方法：

第一个：Skip 自己： 略过几个元素，返回剩下的元素内容

public static IEnumerable<TSource> Skip<TSource> (this IEnumerable<TSource> source, int count);

第二个：SkipLast，从尾巴开始略过几个元素，返回剩下的元素内容

public static IEnumerable<TSource> SkipLast<TSource> (this IEnumerable<TSource> source, int count);

第三个：SkipWhile，跳过满足条件的元素，返回剩下的元素

public static IEnumerable<TSource> SkipWhile<TSource> (this IEnumerable<TSource> source, Func<TSource,bool> predicate);

示例：

// 不保留前10个学生
List<Student> results = students.Skip(10).ToList();
// 不保留后10个学生
List<Student> results = students.SkipLast(10).ToList();
// 只要非一班的学生
List<Student> results = students.SkipWhile(p=>p.Class=="一班").ToList();
//上一行代码 等价于 = students.Where(p=>p.Class != "一班").ToList();

Take 选取几个元素

Take与Skip一样也有三个衍生方法，声明的参数类型也一样，这里就不对声明做介绍了，直接上示例。

//选取前10名同学
List<Student> results = students.Take(10).ToList();
// 选取最后10名同学
List<Student> results = students.TakeLast(10).ToList();
//选取 一班的学生
List<Student> results = students.TakeWhile(p=>p.Class=="一班").ToList();
// 上一行 等价于 = students.Where(p=>p.Class=="一班").ToList();

在使用Linq写分页的时候，就是联合使用Take和Skip这两个方法：

int pageSize = 10;//每页10条数据
int pageIndex = 1;//当前第一页
List<Student> results = students.Skip((pageIndex-1)*pageSize).Take(pageSize).ToList();

其中 pageIndex可以是任意大于0 的数字。Take和Skip比较有意思的地方就是，如果传入的数字比数据源的数据量大，根本不会爆粗，只会返回一个空数据源列表。

Select 选取

官方对于Select的解释是，将序列中的每个元素投影到新的表单里。我的理解就是，自己 定义一个数据源单个对象的转换器，然后按照自己的方式对数据进行处理，选择出一部分字段，转换一部分字段。

所以按我的理解，我没找到java8的同效果方法。（实际上java用的是map，所以没找到，:-D）

public static System.Collections.Generic.IEnumerable<TResult> Select<TSource,TResult> (this IEnumerable<TSource> source, Func<TSource,TResult> selector);

示例：

// 选出班级和姓名
List<object> results = students.Select(p => new
{
    p.Class,
    p.Name
}).ToList();

简单运算操作

Linq 里有几个需要注意的简单运算操作，这部分在使用中很常见。

Max 选取最大的一个

Max获取数据源中最大的一个，不过只能是数字类型的，其他类型因为不能直接比较大小所以可以有替代方法，就是先排序取第一个。

以下是Max方法的两个重载版本：

public static int Max (this IEnumerable<int> source);
public static int Max <TSource>(this IEnumerable<TSource> source,Func<TSource,int> selector);

示例：

//查询学生中最大的年纪是多少
int maxAge = students.Select(t=>t.Age).Max();

Min 选取最小的一个

方法类似与Max，不过与之不同的是获取最小的一个，不能应用于非数字类型。

示例：

// 查询学生中最小的年纪是多少
int minAge = students.Select(t=> t.Age).Min();
//=======
int minAge = students.Min(p=>p.Age);

Average 求平均数

与 Max/Min是一样类型的方法，依旧不能应用于非数字类型。

示例：

// 查询学生的评价年纪
int averageAge = students.Select(t=>t.Age).Average();
int averageAge = students.Average(p=>p.Age);

Sum 求和

对数据源进行求和或者对数据源的某个字段进行求和，还是不能对非数字类型进行求和

示例：

// 一个没有实际意义的求和，学生的年龄总和
int sumAge = students.Select(t=>t.Age).Sum();
//
int sumAge = students.Sum(p=>p.Age);

Contains 是否包含某个元素

判断数据源中是否包含某个元素，返回一个bool值，如果包含则返回true，如果不包含则返回false。该方法有两个重载版本，一个是使用默认的Equals方法，一个是指定一个相等性比较器实现类。

public static bool Contains<TSource> (this IEnumerable<TSource> source, TSource value);

//传入相等性比较器的
public static bool Contains<TSource> (this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer);

值得注意的是，这里的相等比较器是一个接口，也就是说需要使用类来实现这个方法。通常在实际开发过程中，我们会在TSource这个数据源所代表的类上增加 IEqualityCompare的实现。

示例1：

Student student1 = new Student();// 初始化一个学生类
Student student2 = students.First();// 从数据源中取一个

bool isContains = students.Contains(student1);// 返回 false，
bool isContains2 = students.Contains(student2);// 返回 true

说明： 类的默认相等比较是比较是否是同一个对象，即返回的

示例2：

创建一个相等性比较器，值得注意的是，相等性比较器有两个方法，一个是比较元素是否相等，一个是返回元素的HashCode，这两个方法必须在判断元素是否相等上保持结果一致。

public class StudentEqualityCompare: IEqualityComparer<Student>
{
    public bool Equals(Student x, Student y)
    {
        // 省略逻辑
    }

    public int GetHashCode(Student obj)
    {
        //省略逻辑
    }
}

使用：

StudentEqualityCompare compare = new StudentEqualityCompare();
Student student = students.First();
bool isContains = students.Contains(student, compare);

Count/LongCount 数量查询

这是一组行为一样的方法，就是对数据源进行计数，不同的是Count返回int，LongCount返回long。

它们的声明有以下两种，这里选了Count的声明：

public static int Count<TSource> (this IEnumerable<TSource> source);

public static int Count<TSource> (this IEnumerable<TSource> source, Func<TSource,bool> predicate);

示例：

int count = students.Count();//返回一共有多少个学生
int count = students.Count(p=>p.Class=="一班");// 统计一班一共有多少学生

同类型数据源的操作

之前介绍了单个数据源的操作方法，这些方法不会让数据源发生变化，更多的对数据源进行过滤和选择或者统计。现在介绍几个对多个数据源进行操作的方法。

Union 联合另一个同类型的数据源

联合另一个数据源，意思就是把两个数据源合并到一个里面，去掉重复的元素，只保留不重复的元素，并返回这个结果集。

与Contains方法差不多，这个方法有两个重载的版本：

public static IEnumerable<TSource> Union<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second);

public static IEnumerable<TSource> Union<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);

示例：

先假设一个业务场景：

学校举办运动会，现在教务处收到了田径组 500米跑的报名名单和跳远的报名名单，需要看看一共有哪些学生报名了这两项赛事。

// 省略数据源，田径组的名单
IEnumerable<Student> students1 = new List<Student>();
//省略数据源来源，跳远组的名单
IEnumerable<Student> students2 = new List<Student>();


List<Student> all = students1.Union(student2).ToList();

这时候简单统计了一下所有人，但是后来教务处在核对的时候，发现有的人名重复了，需要判断是否是一个人，这时候就必须创建一个相等比较器了。

List<Student> all = students1.Union(student2,compare).ToList();
// 省略compare的实现，具体可参照Contains的比较器

Intersect 获取两个集合中都存在的数据

获取同时存在于两个集合中的元素，与Union类似。

方法的声明如下：

public static IEnumerable<TSource> Intersect<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second);

public static IEnumerable<TSource> Intersect<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);

示例：

继续之前的业务场景，现在教务处需要知道有哪些同学同时报名了两个比赛

List<Student> students = students1.Intersect(students2).ToList();

Except 获取只在第一个数据源中存在的数据

获取只存在于第一个集合的元素，从第一个集合中去除同时存在与第二个集合的元素，并返回。

方法的声明如下：

public static IEnumerable<TSource> Except<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second);

public static IEnumerable<TSource> Except<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);

示例：

继续业务描述，教务处要一份只报名了500米的学生名单：

List<Student> students = students1.Except(students2).ToList();

Reverse 翻转顺序

数据源中的元素原本有一定的顺序，这个方法可以将数据源中的顺序翻转过来，原本是最后一个的变成了第一个

，第一个变成了最后一个。

简单示例：

char[] apple = { 'a', 'p', 'p', 'l', 'e' };

char[] reversed = apple.Reverse().ToArray();

Distinct 去重

对数据源进行去重，然后返回去重之后的结果。同样，这个方法有两个重载版本，一个有比较器，一个没有比较器。

// 不用比较器的
public static IEnumerable<TSource> Distinct<TSource> (this IEnumerable<TSource> source);
// 设置比较器
public static IEnumerable<TSource> Distinct<TSource> (this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer);

示例：

先描述一个可能会出现的场景，每个班级在各个赛事组提交报名信息的时候有点混乱，500米的负责老师把一个班的名单多录了一次，但是学生已经乱序了，现在需要把多录的去掉，也就是对数据进行去重。

List<Student> students = students1.Distinct();

多个类型数据源的操作

之前的方法基本都是对一个类型的数据源进行操作，不会涉及其他类型的数据源。现在介绍一下怎么关联多个类型的数据源，类似于SQL里的多表链接查询。

Join 关联两个数据源

按照一定的逻辑将两个数据源关联到一起，然后选择出需要的数据。

方法有这几个重载版本：

public static IEnumerable<TResult> Join<TOuter,TInner,TKey,TResult> (this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter,TKey> outerKeySelector, Func<TInner,TKey> innerKeySelector, Func<TOuter,TInner,TResult> resultSelector);

//
public static IEnumerable<TResult> Join<TOuter,TInner,TKey,TResult> (this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter,TKey> outerKeySelector, Func<TInner,TKey> innerKeySelector, Func<TOuter,TInner,TResult> resultSelector, IEqualityComparer<TKey> comparer);

这个方法的参数比较多，我们大概介绍一下这个方法的所有参数：

类型参数

• TOuter 第一个序列中的元素的类型。
• TInner 第二个序列中的元素的类型。
• TKey 选择器函数返回的键的类型。
• TResult 结果元素的类型。

参数

• outer IEnumerable 要联接的第一个序列。
• inner IEnumerable 要与第一个序列联接的序列。
• outerKeySelector Func<TOuter,TKey> 用于从第一个序列的每个元素提取联接键的函数。
• innerKeySelector Func<TInner,TKey> 用于从第二个序列的每个元素提取联接键的函数。
• resultSelector Func<TOuter,TInner,TResult> 用于从两个匹配元素创建结果元素的函数。
• comparerIEqualityComparer 用于对键进行哈希处理和比较的 IEqualityComparer。

示例：

假设前天语文老师组织了一场考试，因为是模拟正式考试，所以答题纸上学生都只写了学号，现在需要把考试成绩和学生们联系在一起

List<object> results = students.Join(subjects,
                                     p => p.StudentId, 
                                     s => s.StudentId, 
                                     (p, s) => new 
                                     {
                                         Student = p, 
                                         Subject = s
                                     }).ToList();
/**
返回一个学生和科目的匿名对象，不过被我用object接了，这里会有一个问题，如果有兴致可以提前了解一下C#的var关键字和匿名对象，这部分将会放在C#基础系列补全篇讲解
*/

GroupJoin 关联两个数据源，并分组

基于键值等同性将两个序列的元素进行关联，并对结果进行分组。以上是官方介绍，我在开发过程中并没有使用过这个方法，不过这个方法完全可以认为是Join和Group的组合体，即先进行了一次Join然后又对数据进行一次分组。

方法声明：

// 使用默认比较器
public static IEnumerable<TResult> GroupJoin<TOuter,TInner,TKey,TResult> (this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter,TKey> outerKeySelector, Func<TInner,TKey> innerKeySelector, Func<TOuter,IEnumerable<TInner>,TResult> resultSelector);
//设置比较器
public static IEnumerable<TResult> GroupJoin<TOuter,TInner,TKey,TResult> (this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter,TKey> outerKeySelector, Func<TInner,TKey> innerKeySelector, Func<TOuter,IEnumerable<TInner>,TResult> resultSelector, IEqualityComparer<TKey> comparer);

类型参数

• TOuter 第一个序列中的元素的类型。
• TInner 第二个序列中的元素的类型。
• TKey 键选择器函数返回的键的类型。
• TResult 结果元素的类型。

参数

• outer IEnumerable 要联接的第一个序列。
• inner IEnumerable 要与第一个序列联接的序列。
• outerKeySelector Func<TOuter,TKey> 用于从第一个序列的每个元素提取联接键的函数。
• innerKeySelector Func<TInner,TKey> 用于从第二个序列的每个元素提取联接键的函数。
• resultSelector Func<TOuter,IEnumerable,TResult> 用于从第一个序列的元素和第二个序列的匹配元素集合中创建结果元素的函数。
• comparer IEqualityComparer 用于对键进行哈希处理和比较的 IEqualityComparer。

以下是官方给的示例：

class Person
{
    public string Name { get; set; }
}

class Pet
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}

public static void GroupJoinEx1()
{
    Person magnus = new Person { Name = "Hedlund, Magnus" };
    Person terry = new Person { Name = "Adams, Terry" };
    Person charlotte = new Person { Name = "Weiss, Charlotte" };

    Pet barley = new Pet { Name = "Barley", Owner = terry };
    Pet boots = new Pet { Name = "Boots", Owner = terry };
    Pet whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
    Pet daisy = new Pet { Name = "Daisy", Owner = magnus };

    List<Person> people = new List<Person> { magnus, terry, charlotte };
    List<Pet> pets = new List<Pet> { barley, boots, whiskers, daisy };

    // Create a list where each element is an anonymous 
    // type that contains a person's name and 
    // a collection of names of the pets they own.
    var query =
        people.GroupJoin(pets,
                         person => person,
                         pet => pet.Owner,
                         (person, petCollection) =>
                             new
                             {
                                 OwnerName = person.Name,
                                 Pets = petCollection.Select(pet => pet.Name)
                             });

    foreach (var obj in query)
    {
        // Output the owner's name.
        Console.WriteLine("{0}:", obj.OwnerName);
        // Output each of the owner's pet's names.
        foreach (string pet in obj.Pets)
        {
            Console.WriteLine("  {0}", pet);
        }
    }
}

/*
 This code produces the following output:

 Hedlund, Magnus:
   Daisy
 Adams, Terry:
   Barley
   Boots
 Weiss, Charlotte:
   Whiskers
*/

1.1 数据准备：

因为这篇内容会涉及到多个数据源，所以这里需要准备一些类和数据，以下数据纯属虚构，不涉及到现实。

/// <summary>
/// 学生
/// </summary>
public class Student
{
    /// <summary>
    /// 学号
    /// </summary>
    public long StudentId { get; set; }
    /// <summary>
    /// 姓名
    /// </summary>
    public string Name { get; set; }
    /// <summary>
    /// 年龄
    /// </summary>
    public int Age { get; set; }
    /// <summary>
    /// 班级
    /// </summary>
    public string Class { get; set; }
}
/// <summary>
/// 科目
/// </summary>
public class Subject
{
    /// <summary>
    /// 
    /// </summary>
    public long SubjectId { get; set; }
    /// <summary>
    /// 名称
    /// </summary>
    public string Name { get; set; }
    /// <summary>
    /// 年级
    /// </summary>
    public string Grade { get; set; }
    /// <summary>
    /// 教师
    /// </summary>
    public string Teacher { get; set; }
}

/// <summary>
/// 考试
/// </summary>
public class Exam
{
    /// <summary>
    /// 考试编号
    /// </summary>
    public long ExamId { get; set; }
    /// <summary>
    /// 科目编号
    /// </summary>
    public long SubjectId { get; set; }
    /// <summary>
    /// 学生编号
    /// </summary>
    public long StudentId { get; set; }
    /// <summary>
    /// 分数
    /// </summary>
    public double Score { get; set; }
    /// <summary>
    /// 考试时间：年-月 如202004 表示2020年04月
    /// </summary>
    public int Time { get; set; }
}

数据源：

List<Student> students = new List<Student>();// 学生列表，忽略数据来源
List<Subject> subjects = new List<Subject>();// 科目列表，忽略数据来源
List<Exam> exams = new List<Exam>();// 考试列表，忽略数据来源

2 查询演示

预先介绍一个概念，C#中有一种类型叫做匿名类型。因为C#的要求是万物皆对象，对象皆有类，所以每一个对象或者数据都是有类型在背后支撑的。但是有时候会需要一些一次性的只读类型，这时候声明一个完整的类就有点得不偿失了。什么是一次性的只读类型呢，就是我们只关心它有哪些属性，不关心它有什么方法，同时这个类对应的对象只能在初始化的时候给属性赋值其他时候不能重新赋值，而且这个类型只在方法内部使用，在这个变量使用完成之后这个类型也失去了意义，这种类型就是我们所说的一次性的只读类型。

那么这种类型怎么声明呢？先不急，先再介绍一个关键字var。这个关键字有什么特别的地点吗？var 表示隐式“类型”，意思就是用var声明的变量其类型需要编译器自己结合上下文推断，也就是说使用者和声明者都知道这个变量的类型，但是没有明说。

那么为什么需要介绍var呢？原因在于，var 是匿名对象的基础。因为匿名对象不能用object声明变量，原因有两点，第一，变量声明为object之后，我们所需要的属性就无法使用了；第二，匿名类型的对象无法直接类型转换为object。所以，想要正常使用匿名类型，必须用var。

下面简单演示一下匿名类型的声明和使用：

var obj = new 
{
    Name = "萧三",
    Age = 20
};
// obj.Name 萧三
// obj.Age 20

这就是匿名类型，声明了一个有Name和Age属性的对象，这个对象我们知道它有哪些属性，但是不知道它的类型是什么。

在介绍完需要的知识后，将通过实际的情况来比较一下流式查询和查询表达式两种写法。

2.1 简单查询

1. 查询班级是三年一班的所有同学

   // 流式查询
   var results = students.Where(t=>t.Class=="三年一班");
   // 查询表达式
   var results = from s in students
       where s.Class == "三年一班"
       select s;

这两种查询方式结构都是IEnumerable 。

1. 获取姓张的所有学生的花名册

// 流式查询
   var results = students.Where(t=>t.Name.StartWith("张"));
   // 查询表达式
   var results = from s in students where s.Name.StartWith("张") select s;

1. 按班级进行分组获取每个班的学生花名册

 // 流式查询
   var results = students.GroupBy(t => t.Class);
   // 查询表达式
   var results = from s in students group s by s.Class;
   // 注明：完整的写法如下：
   // var results = from s in students group s by s.Class into g select g;

需要注意的是，如果返回结果是一个分组的结果，那么就不用select了。

1. 查询每个班的平均年龄

// 流式查询
   var results = students.GroupBy(t => t.Class)
                   .Select(t => new {Class = t.Key, AveAge = t.Average(p => p.Age)});
   // 查询表达式
   var results = from s in students
                   group s by s.Class
                   into g
                   select new {Class = g.Key, AveAge = g.Average(t => t.Age)};

查询表达式中没有统计查询的相关关键字，只能通过方法来获取，同时查询表达式返回的是一个集合，所以没法直接通过查询表达式进行求和、求平均等。

1. 对所有学生按照年龄大小从大到小进行排序

 // 流式查询
   var results = students.OrderByDescending(t => t.Age);
   // 查询表达式
   var results = from s in students orderby s.Age descending select s;

1. 对所有学生按照年龄大小从小到大进行排序

// 流式查询
   var results = students.OrderBy(t => t.Age);
   // 查询表达式
   var results = from s in students orderby s.Age select s;

1. 先按年龄排序再按姓名进行排序

 // 流式查询
   var results = students.OrderBy(t => t.Age).ThenBy(t=>t.Name);//ThenByDescending 是降序版的ThenBy
   // 查询表达式
   var results = from s in students orderby s.Age //descending 如果是降序则增加这个关键字
       , s.Name select s;

2.2 复杂查询

前一部分介绍了简单的查询，这一部分介绍联合多个数据源进行一系列的查询操作。

1. 查询三年级语文科目在202004月举行的考试的所有成绩

 // 流式查询
   var results = subjects.Join(exams, s => s.SubjectId, e => e.StudentId, (s, e) => new
   {
       s.Name,
       s.Grade,
       e.Score,
       e.Time
   }).Where(t=>t.Grade == "三年级" && t.Name =="语文" && t.Time == 202004).Select(t=>t.Score);
   // 查询表达式
   var results = from s in subjects
                   join e in exams on s.SubjectId equals e.SubjectId
                   where e.Time == 202004 && s.Grade == "三年级" && s.Name == "语文"
                   select e.Score;

1. 按年级进行分组，查询各年级语文分数

// 流式查询
   var results = subjects.Where(p => p.Name == "语文")
                   .Join(exams, s => s.SubjectId, e => e.SubjectId, (s, e) => new {s.Grade, e.Score})
                   .GroupBy(t => t.Grade);
   // 查询表达式
   var results = from s in subjects
                   join e in exams on s.SubjectId equals e.SubjectId
                   where s.Name == "语文"
                   group e.Score by s.Grade
                   into g
                   select g;

1. 求各年级历次考试各科目分数的平均分和最高分以及最低分

   var results = subjects.Join(exams, s => s.SubjectId, e => e.SubjectId, (s, e) => new
               {
                   s.Grade,
                   s.Name,
                   e.Score
               }).GroupBy(t => t.Grade).Select(t => new
               {
                   Grade = t.Key,
                   Subjects = t.GroupBy(p => p.Name).Select(p => new
                   {
                       Name = p.Key,
                       Max = p.Max(r => r.Score),
                       Min = p.Min(r => r.Score),
                       Average = p.Average(r => r.Score)
                   })
               });
   //查询表达式
   var results = from s in subjects
                   join e in exams on s.SubjectId equals e.SubjectId
                   let o = new {s.Grade, s.Name, e.Score}
                   group o.Score by new {o.Grade, o.Name}
                   into o
                   let p = new
                   {
                       o.Key.Grade, Subject = new {o.Key.Name, 
                                                   Max = o.Max(),
                                                   Min = o.Min(), 
                                                   Average = o.Average()}
                   }
                   group p.Subject by p.Grade
                   into g
                   
                   select new
                   {
                       Grade = g.Key,
                       Subjects = g.AsEnumerable()
                   };