1.转换操作符
1.ToArray
从一个类型为T的输入序列创建一个类型为T的数组。
2.ToList
从一个类型为T的序列创建一个类型为T的列表。
3.ToDictionary
从类型为T的序列创建一个类型为<TKey, TSource>的字典，如果该原型包含elementSelector参数，则创建一个类型
为<TKey, TElement>的字典。
//
// 第一个原型:
/*Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(
* this IEnumerable<TSource> source,
* Func<TSource, TKey> keySelector);*/
{
Dictionary<int, Employee> eDictionary =
Employee.GetEmployeesArray().ToDictionary(k => k.id);
Employee e = eDictionary[2];
Console.WriteLine("Employee whose id == 2 is {0} {1}",e.firstName,e.lastName);
}
//
//第二个原型：
/* Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(
* this IEnumerable<TSource> source,
* Func<TSource, TKey> keySelector,
* IEqualityComparer<TKey> comparer); //多一个 IEqualityComparer<TKey> 比较功能
*/
/* 第三个原型：
* Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(
* this IEnumerable<TSource> source,
* Func<TSource, TKey> keySelector,
* Func<TSource, TElement> elementSelector);
* 与第一原型相比，多一个元素选择器，Dictionary存储的值就可以不同于输入序列元素的类型。
*/
{
Dictionary<int, string> eDictionary = Employee.GetEmployeesArray()
.ToDictionary(k => k.id,
i => string.Format("{0} {1}", i.firstName, i.lastName)); //elementSelector
string name = eDictionary[2];
Console.WriteLine("Employee whose id == 2 is {0}", name);
//Employee whose id == 2 is Willam Gates
}
4.ToLookup
单个键可以存储多个值，它是一对多，不像Dictionary<TKey,TElement>一样是一对一的。
Lookup<int,int>和Dictionary<int,List<int>>是一样的。
从类型T的输入序列中创建一个类型为<TKey, TSource>或<TKey, TElement>的查找（Lookup），这里TKey是键的类型，TSource是存储的值类型。
如果Lookup类型为<TKey, TElement>,则存储的值类型为TElement，该类型与序列中元素类型T不同。
//第一个原型
/*ILookup<TKey, TSource> ToLookup<TSource, TKey>(
* this IEnumerable<TSource> source,
* Func<TSource, TKey> keySelector);
*/
{
ILookup<int, Actor> lookup = Actor.GetActors().ToLookup(k => k.birthYear);
//看看是否能找到出生于1964年的人
IEnumerable<Actor> actors = lookup[1964];
foreach (var actor in actors)
Console.WriteLine("{0} {1}", actor.firstName, actor.lastName);
//Keanu Reeves, Sandra Bullock
}
//第三种原型
/*ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(
* this IEnumerable<TSource> source,
* Func<TSource, TKey> keySelector,
* Func<TSource, TElement> elementSelector);*/
//允许开发者指定元素选择器，存储值类型与输入序列元素类型不同
{
ILookup<int, string> lookup = Actor.GetActors().ToLookup(k => k.birthYear,
i => string.Format("{0} {1}", i.firstName, i.lastName)); //elementSelector
//看看是否能找到出生于1964年的人
IEnumerable<string> actors = lookup[1964];
foreach (var actor in actors)
Console.WriteLine("{0} ", actor);
//Keanu Reeves, Sandra Bullock
}
2.相等操作符
1.SequenceEqual
以并行方式枚举每个序列，使用System.Object.Equals方法比较每个序列中的袁旭。如果这些元素全部相等，并且这两个序列具有相同数量元素，
则返回 true，否则返回 false。
//
/*bool SequenceEqual<TSource>(
* this IEnumerable<TSource> first,
* IEnumerable<TSource> second);*/
{
string[] Presidents = { "Adams", "Arthur", "Buchanan" };
string[] Presidents1 = { "Arthur", "Adams", "Buchanan" };
bool isEquals = Presidents.SequenceEqual(Presidents1);
Console.WriteLine(isEquals); //false
}
3.元素操作符
1.First
返回输入序列第一个元素。
2.FirstOrDefault
返回输入序列第一个元素。如果该序列为空，则返回default(T)。对于引用和可空类型，则默认为null。
3.Last
返回一个序列的最后一个元素。
4.LastOrDefault
返回最后一个元素，如果该序列为空，则返回default(T)。对于引用和可空类型，则默认为null。
5.Single
只返回单个元素序列中的唯一元素，或者一个匹配谓词的序列中的唯一元素。
6.SingleOrDefault
只返回单个元素序列中的唯一元素，如果该序列为空，则返回 default(T)。对于引用和可空类型，则默认为null。
如果找到了多于一个的元素，则产生 InvalidOperationException异常。
7.ElementAt
返回源序列中指定索引的元素。
Employee emp = Employee.GetEmployeesArray().ElementAt(3);
Console.WriteLine("{0} {1}",emp.firstName,emp.lastName);
8.ElementAtOrDefault
返回源序列中指定索引的元素。
如果索引小于0或者大于等于序列的元素数量，则返回default(T)。对于引用和可空类型，则默认为null。（与ElementAt的区别）
Employee emp = Employee.GetEmployeesArray().ElementAtOrDefault(5);
Console.WriteLine(emp == null ? "NULL" : string.Format("{0} {1}", emp.firstName, emp.lastName));
//结果：NULL
3.量词操作符
1.Any
任何元素满足某个条件，则Any返回true。
//第一原型：
/*Any<TSource>(
* this IEnumerable<TSource> source);
* 如果 source 序列包含任何元素，则 Any 返回 true。
*/
//第二原型：
/*bool Any<TSource>(
* this IEnumerable<TSource> source,
* Func<TSource, bool> predicate);
* 如果 predicate 返回 ture，则 Any 返回True。
*/
{
string[] Presidents ={
"Adams", "Arthur", "Buchanan", "Bush", "Carter", "Cleveland",
"Clinton", "Coolidge", "Eisenhower", "Fillmore", "Ford", "Garfield",
"Grant", "Harding", "Harrison", "Hayes", "Hoover", "Jackson",
"Jefferson", "Johnson", "Kennedy", "Lincoln", "Madison", "Mckinley",
"Monroe", "Nixon", "Pierce", "polk", "Reagan", "Roosevelt", "Taft",
"taylor", "Trumanyler", "Van Buren", "Washington", "Wilson"
};
bool any = Presidents.Any(); //true
bool anyPredicate = Presidents.Any(s=>s.StartsWith("Z")); //false
}
2.All
所有元素都满足某个条件，则返回True。
bool all = Presidents.All(s => s.Length > 5);
Console.WriteLine(all);//false，不是所有元素长度都大于5
3.Contains
是否包含元素，则返回 true。
5.聚合操作符
1.Count
返回元素中序列的数量。
2.LongCount
以long型整数返回输入序列的元素。
3.Sum
返回序列的元素中包含的数字值的总和。
4.Min
返回输入序列中最小值。
//
int[] myInts = new[] {974, 2, 7, 1374, 27, 54};
/*Numeric Min(this IEnumerable<Numeric> source); (Numeric数字类型)*/
int minInt = myInts.Min();
Console.WriteLine(minInt);
/*TSource Min<TSource>(this IEnumerable<TSource> source);
* 返回非数字类型*/
string minName = Presidents.Min();
Console.WriteLine(minName);
/*Min<TSource>(
* this IEnumerable<TSource> source,
* Func<TSource, Numeric> selector); (Numeric数字类型)
* 用于数字类型，selector委托允许对元素成员变量进行比较 */
int oldeatActorAge = Actor.GetActors().Min(a => a.birthYear);
Console.WriteLine(oldeatActorAge);
/*Min<TSource, TResult>(
* this IEnumerable<TSource> source,
* Func<TSource, TResult> selector);
* 用于非数字类型 */
string firstAlphabetically = Actor.GetActors().Min(a => a.lastName);
Console.WriteLine(firstAlphabetically);
/*2
Adams
1960
Bullock*/
5.Max
返回输入序列中最大值。
6.Average
返回序列元素的平均值。
7.Aggregate
对序列每个元素执行开发者指定特定函数，将前一个元素的返回值传入该函数，并返回最后一个元素的返回值。
//第一种原型：
/* TSource Aggregate<TSource>(
* this IEnumerable<TSource> source,
* Func<TSource, TSource, TSource> func);
* 对每个元素调用func方法委托，将前一个元素返回值传入委托中作为第一个参数，该元素本身作为第二个参数，
* 最后将func返回值存储在一个内部加法器中，然后将该值传递到下一个元素，
* 第一个元素将自身作为输入值传递到 func 方法委托中 */
{
int N = 5;
IEnumerable<int> intSequence = Enumerable.Range(1, N);
foreach (int sequence in intSequence)
{
Console.WriteLine(sequence);
}
//下面计算这个阶乘
//av==乘积,e==元素
int agg = intSequence.Aggregate((av, e) => av*e);
Console.WriteLine("{0}! = {1}",N,agg);
/* 5! = 120*/
}
//第二种原型
/*TAccumulate Aggregate<TSource, TAccumulate>(
* this IEnumerable<TSource> source,
* TAccumulate seed, //seed作为第1个参数，而不再是第一个元素本身。
* Func<TAccumulate, TSource, TAccumulate> func);*/
{
IEnumerable<int> intSequence = Enumerable.Range(1,10);
foreach (int item in intSequence)
{
Console.WriteLine(item);
}
Console.WriteLine("----");
int sum = intSequence.Aggregate(1, (s, i) => s + i);
Console.WriteLine(sum);
//56
}