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 類型的輸出。

按照 MSDN 上的說明，輸入的第一個參數是累加的值，第二個參數是元素。

{
    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 !

在第一次進入 Aggregate 的 Func 時，combine 的值為第一個元素的值，str 為第二個元素的值。

當輸入的序列的元素個數為 0 時，則拋出 InvalidOperationException 異常。

而當元素的個數只有一個的時候，則不會執行 Func。

接下來看第二個重載

Aggregate<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>)

比起第一個重載，多了一個參數輸入參數 TAccumulate，泛型參數也變成了兩個。

{
    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 平時也用得比較多，因此也不說了。