我们先来假设这种场景：
一个学校中有多个年级，一个年级有多个班级，一个班级里有多个学生。这里我们只需要班级、年级、和学生这三个概念；
让我们先来定义Class类和Student类：
// 注意，Class是班级而不是 教室的意思，教室是 Classroom。
public class Class
{
public int ClassId { get; set; }
// 同一个班级的学生必然是属于同一个年级的，故GradeId直接在Class中声明就可以了。
public int GradeId { get; set; }
public List<Student> Students { get; set; }
} public class Student
{
public int StudentId { get; set; }
// 外键 ClassId
public int ClassId { get; set; }
public string OtherProp{ get; set; }
// 注意，学生没有GradeId属性
}
现在来声明多个班级：
List<Class> classes = new List<Class>();
classes.AddRange(...); // 这里添加的Class是有属于不同年级的
现在来看SelectMany(...);函数的声明：
声明一：
public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector);
声明二：
public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
对于第一个声明：我们调用该函数的形式即为：
classes.SelectMany(cls=>cls.Students); // 这里很重要的一点，Func<TSource,IEnumerable<TResult>>里面的不是参数，而是类型，Func中最后一个泛型一定是返回值的泛型类型
// 这里classes 就是函数原型声明中的 source，而TSource就是Class类型，TResult就是 Student类型；而对于委托参数 selector中的 IEnumerable<TResult>实际上就是当前cls
// 代表的班级的所有学生，直接用cls.Students即可（而不是说自己声明一个 IEnumerable<Student> studs，然后将studs传到Func中，该Func只有一个参数）。
如上所示的代码实际上就是将多个班级classes中的所有学生都选出来返回一个 IEnumerable<Student> students，但是这里会存在一个问题，就是students中的学生
是classes中的学生总和，但是这时候我们无法知道students中某学生所属的年级是哪个了，如果想在返回classes中所有学生的集合的同时，对Student删减一些属性和
增加GradeId属性，这时候可以用第二个声明的SelectMany(..)函数，调用方法如下：
// 这里 cls就是声明二中的对应第一个委托Func的参数，TSource就是Class类型，cls.Students即是IEnumerable<TCollection>类型返回值，TCollection就是Student类型
// 而stud 就是cls.Students中的某一个元素，new{....}返回的类型是匿名类型，就是 TResult类型。
classes.SelectMany(cls=>cls.Students,(cls,stud)=>new{
ClassId=stud.ClassId,GradeId=cls.GradeId,StudentId=stud.StudentId}); // 这里的属性的增减 形式是随自己需要来改变的，不一定就是要这样
这时候返回的 IEnumerable<TResult> ches变量就是 对原来的Student进行了属性增减后的新类型（匿名类型'a）的集合，ches集合的元素个数和之前
classes.SelectMany(cls=>cls.Students)返回的元素个数是一样的。这时候要遍历ches 就不能用具体类型，只能用XXX(var itm in ches) 了。
现在来看看第二个声明的SelectMany(...)的内部实现的一种方式及其伪代码：
// TResult对应 'a匿名类型；TSource对应Class类型；TCollection对应Student类型
// source 对应classes
public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source,
Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
{
IEnumerable<TResult> listResult = new IEnumerable<TResult>();
// source 对应 classes
foreach(var cls in source)
{
// TCollection对应Student，blockStudents对应 当前班级 cls中的所有学生集合
// 给collectionSelector传 Lambda表达式时给出了该委托承载的 函数的具体声明 cls=>cls.Students。
// Lambda表达式产生的 匿名函数的 参数类型，返回值类型一定是已知的，这里是Class和IEnumerable<Student>
IEnumerable<TCollection> blockStudents = collectionSelector(cls); /* 如果是第一个声明，那么这时候就会开始执行 listResult.AddRange(blockStudents);此时Student即是TResult*/ foreach(var stud in blockStudents) // 注意，这是第二层 foreach
{
// resultSelection(cls,stud) 返回的是 TResult，即匿名类型 'a 的实体对象，并添加到 listResult中
// resultSelection承载的Lambda表达式为：(cls,stud)=>new {ClassId.......GradeId...} ；new出的
// 匿名对象即为 TResult 类型。
listResult.Add(resultSelection(cls, stud));
} // Second Foreach End
} // First Foreach End
return listResult;
} // SelectMany(...) End