LINQ之延迟执行标准查询操作符(中)
操作符：Concat
描述：用于连接2个序列
原型：1种
public static IEnumerable<TSource> Concat<TSource>( this IEnumerable<TSource> first, IEnumerable<TSource> second )
string [] dogs = {"kelly","belly","shelly"};
string[] cats = {"kiti", "lili"};
var pets = dogs.Concat(cats);
foreach (var pet in pets)
{
Console.WriteLine(pet);
}
返回的结果是：
kelly
belly
shelly
kiti
lili
操作符：OrderBy
描述：允许输入序列根据一个keySelector方法进行升序排序，并返回一个排序后的结果：IOrderedEnumerable<TSource>
原型：2种
原型一：
public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>( this IEnumerable<TSource> source, Func<TSource, TKey> keySelector )
在这种原型中，TKey必须是实现了IComparable<TKey>
string [] dogs = {"kelly","belly","shelly"};
string[] cats = {"kiti", "lili"};
var pets = dogs.Concat(cats).OrderBy(item=>item);
foreach (var pet in pets)
{
Console.WriteLine(pet);
}
需要注意的是，OrderBy后返回的是一个已经排序的结果：IOrderedEnumerable<TSource>，此时我们不应该在对这个序列调用OrderBy方法，
因为这样会破坏原有的OrderBy的排序，如果我们需要再次针对其他的key进行排序，可以调用ThenBy，稍后会提到。
原型二：
public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>( this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer )
原型二和原型一很类似，只是多提供了一个IComparer的参数，允许我们传入自己的排序算法。这样子的话，TKey就不一定要是想IComparer接口了。
我们还是来看个例子：
我们有一个Student类：
public class Student
{
public string Name { get; set; }
public List<int > Scores { get; set; }
}
我们希望根据Student的Scores的和来做一个降序排序，因此，我们另外建一个类来实现IComparer：
public class SortStudentScore:IComparer<Student>
{
public int Compare(Student x, Student y)
{
decimal xScores = x.Scores.Sum(item => item);
decimal yScores = y.Scores.Sum(item => item);
return yScores.CompareTo(xScores);
}
}
这样，我们的查询可以写成：
//定义数据源
List<Student> students = new List<Student>
{
new Student{Name = "Terry",Scores = new List<int>{98,88,93,75,82}},
new Student{Name = "Tina",Scores = new List<int>{85,99,87,93,97}},
new Student{Name = "Linda",Scores = new List<int>{57,100,83,89,92}},
new Student{Name = "Leon",Scores = new List<int>{100,98,72,77,84}},
new Student{Name = "Echo",Scores = new List<int>{79,80,97,55,88}}
};
SortStudentScore sortStudentScore = new SortStudentScore();
//定义查询表达式，找出不及格的学生及其分数
var scoreQuery = students.OrderBy((s => s),sortStudentScore).Select(item=>new {item.Name,TotalScore= item.Scores.Sum(score=>score)});
//输出结果)
foreach (var query in scoreQuery)
{
Console.WriteLine("Student:{0} TotalScore:{1}", query.Name, query.TotalScore);
}
我们的输出结果就是：
Student:Tina TotalScore:461
Student:Terry TotalScore:436
Student:Leon TotalScore:431
Student:Linda TotalScore:421
Student:Echo TotalScore:399
操作符：OrderByDescending
描述：与OrderBy操作符类似，只是排序方式是按照降序来排序的。
原型：与OrderBy一样，支持2种原型
具体例子可以参照OrderBy的，不再赘述。
操作符：ThenBy
描述：将一个已经排序后的序列，根据新的key进行再排序。主要，与大多数LINQ操作不一样的地方是，ThenBy(以及后面要介绍的ThenByDescending)的输入序列都必须是实现了
IOrderedEnumerable<T>。由于ThenBy是稳定排序，因此对于OrderBy/OrderByDescending后，ThenBy的key相同的2个元素，不会再打乱其排序。
原型：2种，跟OrderBy一样
为了说明这点，我们举个例子：
//定义数据源
List<Student> students = new List<Student>
{
new Student{Id = 1,Name = "Leon",Scores = new List<int>{98,88,93,75,82}},
new Student{Id = 2,Name = "Tina",Scores = new List<int>{85,99,87,93,97}},
new Student{Id = 3,Name = "Linda",Scores = new List<int>{57,100,83,89,92}},
new Student{Id = 4,Name = "Leon",Scores = new List<int>{100,98,77,77,84}},
new Student{Id = 5,Name = "Echo",Scores = new List<int>{79,80,97,55,88}}
};
SortStudentScore sortStudentScore = new SortStudentScore();
var orderByScoreQuery = students.OrderBy((s => s), sortStudentScore).
Select(item => new {item.Id, item.Name, TotalScore = item.Scores.Sum(score => score) });
Console.WriteLine("Using OrderBy only");
//输出结果));
foreach (var query in orderByScoreQuery)
{
Console.WriteLine("{0}.{1} TotalScore:{2}",query.Id, query.Name, query.TotalScore);
}
Console.WriteLine();
Console.WriteLine("After add ThenBy");
//定义查询表达式，找出不及格的学生及其分数
var scoreQuery = students.OrderBy((s => s), sortStudentScore).
ThenBy(item=>item.Name).
Select(item => new {item.Id, item.Name, TotalScore = item.Scores.Sum(score => score) });
//输出结果)
foreach (var query in scoreQuery)
{
Console.WriteLine("{0}.{1} TotalScore:{2}", query.Id, query.Name, query.TotalScore);
}
为了说明这个例子，我们让两个学生同名，并且总分也一样，用Id来区别他们，以下是输出结果：
Using OrderBy only
2.Tina TotalScore:461
1.Leon TotalScore:436
4.Leon TotalScore:436
3.Linda TotalScore:421
5.Echo TotalScore:399
After add ThenBy
2.Tina TotalScore:461
1.Leon TotalScore:436
4.Leon TotalScore:436
3.Linda TotalScore:421
5.Echo TotalScore:399
我们发现Id 1和Id 4经过ThenBy后，并没有调整顺序。对于像List.Sort<T>这种不稳定排序，相同的值排序后可能打乱掉原有的顺序的。
操作符：Reverse
描述：Reverse很简单，就是将序列逆序一下
原型：
public static IEnumerable<TSource> Reverse<TSource>( this IEnumerable<TSource> source )
看个简单的例子吧：
int[] nums = new int[] { 0,1,2,3,4,5 };
var evenNums = nums.Reverse();
foreach (var evenNum in evenNums)
{
Console.WriteLine(evenNum);
}
输出的结果为：
5
4
3
2
1
0
To Be Continue…
参考：《Pro.LINQ.Language.Integrated.Query.in.Csharp.2010》
