Linq 虽然用得多,可是里面有一些方法比较少用,所以整理一下。Enumerable 类的全部方法能够在 MSDN 上查阅到:https://msdn.microsoft.com/zh-cn/library/system.linq.enumerable.aspx数组
Aggregate
这个方法有三个重载,先看第一个测试
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>)
参数是接受两个 TSource 类型的输入,返回一个 TSource 类型的输出。spa
按照 MSDN 上的说明,输入的第一个参数是累加的值,第二个参数是元素。3d
{
int[] array = new[] { 1, 2, 3, 4, 5 };
int result = array.Aggregate((sum, i) => sum + i);
Console.WriteLine(result);
}
{
string[] array = new string[] { "hello", "world", "!" };
string result = array.Aggregate((combine, str) =>
{
return combine + " " + str;
});
Console.WriteLine(result);
}
则会输出 15 和 hello world !code
在第一次进入 Aggregate 的 Func 时,combine 的值为第一个元素的值,str 为第二个元素的值。blog
当输入的序列的元素个数为 0 时,则抛出 InvalidOperationException 异常。索引

而当元素的个数只有一个的时候,则不会执行 Func。ip
接下来看第二个重载get
Aggregate<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>)
比起第一个重载,多了一个参数输入参数 TAccumulate,泛型参数也变成了两个。string
{
int[] array = new[] { 1, 2, 3, 4, 5 };
long result = array.Aggregate(-1L, (sum, i) =>
{
return sum + i;
});
Console.WriteLine(result);
}
那么这段代码的输出则会是 14。第一次进入 Func 的时候,sum 的值为 -1L,i 的值是 1,这个行为跟第一个重载稍微有点区别。
并且当元素只有一个的时候,也是会进入 Func 的

当序列为空的时候,也不会触发到异常

直接等于输入参数的值。
第三个重载
Aggregate<TSource, TAccumulate, TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>, Func<TAccumulate, TResult>)
这个其实就是至关与第二个重载增长了最后一个参数
{
string[] array = new string[] { "hello", "world", "!" };
string result = array.Aggregate("start", (combine, str) =>
{
return combine + " " + str;
}, end => end.ToUpperInvariant());
Console.WriteLine(result);
}
执行后会输出 START HELLO WORLD !。
最后的那个参数相对于对最终结果进行了一下处理,跟下面的代码是等价的。
{
string[] array = new string[] { "hello", "world", "!" };
string result = array.Aggregate("start", (combine, str) =>
{
return combine + " " + str;
}).ToUpperInvariant();
Console.WriteLine(result);
}
DefaultIfEmpty
第一个重载
DefaultIfEmpty<TSource>(IEnumerable<TSource>)


就是说,若是一个序列的元素个数是零个的话,那就返回一个只有一个 default(TSource) 元素的序列。感受这没啥用(lll¬ω¬)
看另外一个重载
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)
多了个参数,猜也猜得出来了


唔,好像仍是没啥实用意义…………
Except
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
求差集

A 序列减去 B 序列,而且去重了。
另外一重载
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
多了一个比较器

最后只会输出 Hello,由于在 IgnoreCase 比较器下,world 和 WORLD 是同样的。
GroupBy
虽然用得仍是比较多,可是重载比较多,仍是写一下吧。
GroupBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)
这个是最简单的重载了。

根据 Age 分组,这个重载很简单,也是最经常使用的。
GroupBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>)
多了一个比较器,不难


Key 会根据第一次匹配到的值。
GroupBy<TSource, TKey, TElement>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>)

第一个重载的改版并且,若是将上面的 person => person.Name 改成 person => person,那跟第一个重载没区别。
GroupBy<TSource, TKey, TElement>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)
多了一个比较器而已,不说了。
GroupBy<TSource, TKey, TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, IEnumerable<TSource>, TResult>)

分完组后对每一组进行了一下处理。
GroupBy<TSource, TKey, TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, IEnumerable<TSource>, TResult>, IEqualityComparer<TKey>)
比上面多了一个比较器,不说了。
GroupBy<TSource, TKey, TElement, TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)
多了元素选择的参数重载,参考上面。
GroupBy<TSource, TKey, TElement, TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)
多了选择器,不说。
Join
Join<TOuter, TInner, TKey, TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter, TKey>, Func<TInner, TKey>, Func<TOuter, TInner, TResult>)
这个其实不难,只要参考一下 SQL 中的 inner join 的话。
先初始化测试数据
List<Person> list1 = new List<Person>()
{
new Person()
{
Id = 1,
Gender = "M"
},
new Person()
{
Id = 2 ,
Gender = "F"
},
new Person()
{
Id = 3,
Gender = "M"
}
};
List<Student> list2 = new List<Student>()
{
new Student()
{
Id = 1,
Name = "martin"
},
new Student()
{
Id = 2,
Name = "valid void"
},
new Student()
{
Id = 4,
Name = "justin"
}
};
而后测试代码走起

没啥难的,等价于如下的 linq 写法

Join<TOuter, TInner, TKey, TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter, TKey>, Func<TInner, TKey>, Func<TOuter, TInner, TResult>, IEqualityComparer<TKey>)
多了个比较器,用于比较 key,不说了。
GroupJoin
GroupJoin<TOuter, TInner, TKey, TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter, TKey>, Func<TInner, TKey>, Func<TOuter, IEnumerable<TInner>, TResult>)
看上去很复杂,但其实能够参考 Join 的输入进行对比。
测试数据咱们仍是沿用 Join 的。执行测试代码

对等的 linq 写法以下
var result = (from person in list1
join student in list2 on person.Id equals student.Id into studentGroup
select new
{
Id = person.Id,
Gender = person.Gender,
Students = studentGroup.ToList()
}).ToList();
GroupJoin<TOuter, TInner, TKey, TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter, TKey>, Func<TInner, TKey>, Func<TOuter, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)
多了一个比较器,不说了。
SelectMany
这个最近这段时间用得比较多,也记录一下吧
SelectMany<TSource, TResult>(IEnumerable<TSource>, Func<TSource, IEnumerable<TResult>>)
测试代码

简单的来讲就是将一个 IEnumerable<IEnumerable<T>> 的序列变成一个 IEnumerable<T> 的序列。
对等的 linq 写法

感受 linq 写法会相对比较好理解的说。
SelectMany<TSource, TResult>(IEnumerable<TSource>, Func<TSource, Int32, IEnumerable<TResult>>)
Func 多了个 Int32 的参数,看测试代码


很好理解,就是当前的索引。
SelectMany<TSource, TCollection, TResult>(IEnumerable<TSource>, Func<TSource, IEnumerable<TCollection>>, Func<TSource, TCollection, TResult>)
比起第一个就是多了个结果执行而已

会进入这个 Func 四次,前两次是 helloword 那个 List,后两次是 justin martin 那个 List。
SelectMany<TSource, TCollection, TResult>(IEnumerable<TSource>, Func<TSource, Int32, IEnumerable<TCollection>>, Func<TSource, TCollection, TResult>)
多了索引,参考上面。
SequenceEqual
序列比较,知道有这个东西,但平时好像没有怎么用过。
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

很好理解,首要前提确定是元素个数相等,其次要每个元素相等。
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
多了个比较器,不说了。
SkipWhile
Skip 却是一直在用,SkipWhile 就用得比较少,也记录一下吧。
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource, Boolean>)
不难,就是当 Func 返回 false 时中止。

由于当去到 3 的时候为 false,所以返回 3 和剩下的元素。
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource, Int32, Boolean>)
多了个索引而已,没啥好说的。
ToDictionary
先看第一个重载
ToDictionary<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)
不难,Func 就是获取按照什么来生成 Key。

另外使用这个方法是要注意,Key 是不能重复的。

因此说实话,这方法平时比较少用。。。
ToDictionary<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>)
多了一个比较器,没啥好说的。
ToDictionary<TSource, TKey, TElement>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>)
比起第一个重载,多了一个如何生成字典的值的 Func,也没啥好说的。
ToDictionary<TSource, TKey, TElement>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)
多了比较器,不说了。
ToLookup
这个有点像上面的 ToDictionary 的。
ToLookup<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)
跟 ToDictionary 的第一个重载的输入参数是同样的。

ILookup<int, Person> 这个的结构相似于一个数组,而后每一个数组的元素是一个 Group。
当元素的 Key 重复的时候:

那么这个 lookup 就只有一个 group 了,但这个 group 就会有多个元素。
ToLookup<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>)
ToLookup<TSource, TKey, TElement>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>)
ToLookup<TSource, TKey, TElement>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)
这三个重载能够参考一下 ToDictionary 的重载,同样的说。
Zip
这个方法就只有一个,没别的重载
Zip<TFirst, TSecond, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TSecond, TResult>)

这里就借用 MSDN 上的示例代码了,看结果也看得出 Zip 这个操做的逻辑了。遍历两个序列进行操做,直到其中一个到达尾部。
另外像 TakeWhile 能够参考上面的 SkipWhile 就不说了。Distinct、Union 和 Intersect 平时也用得比较多,所以也不说了。