Linq 拡張メソッド一覧

# System.Linq.Enumerable

コレクション (IEnumerable&lt;T&gt;) の拡張メソッドを分類

|分類|名称|機能|例|
|---|---|---|---|
|生成|[Empty]|空のコレクションを取得|[※](#empty)|
|生成|[Repeat]|指定数のコレクションを取得|[※](#repeat)|
|生成|[Range]|指定範囲の整数コレクションを取得|[※](#range)|
|||||
|変換|[AsEnumerable]|IEnumerable&lt;T&gt; 型に変換|[※](#asenumerable)|
|変換|[Cast]|要素を指定した型に変換<br>変換できない場合は例外|[※](#cast)|
|変換|[ToArray]|配列に変換|[※](#toarray)|
|変換|[ToList]|リストに変換|[※](#tolist)|
|変換|[ToDictionary]|ディクショナリに変換|[※](#todictionary)|
|変換|[ToLookup]|分類|[※](#tolookup)|
|||||
|判定|[Contains]|要素を含んでいるか判断|[※](#contains)|
|判定|[All]|すべての要素が条件を満たしているか判断|[※](#all)|
|判定|[Any]|どれかの要素が条件を満たしているか判断|[※](#any)|
|判定|[SequenceEqual]|要素が等しいか判断|[※](#sequenceequal)|
|||||
|単一要素|[ElementAt]<br>[ElementAtOrDefault]|指定位置の要素を取得|[※](#elementat--elementatordefault)|
|単一要素|[Single]<br>[SingleOrDefault]|単一の要素を取得<br>複数ある場合は例外or既定値|[※](#single--singleordefault)|
|単一要素|[First]<br>[FirstOrDefault]|最初の要素を取得<br>見つからない場合は例外or既定値|[※](#first--firstordefault)|
|単一要素|[Last]<br>[LastOrDefault]|最後の要素を取得<br>見つからない場合は例外or既定値|[※](#last--lastordefault)|
|||||
|複数要素|[OfType]|指定した型でフィルタ|[※](#oftype)|
|複数要素|[Where]|指定した条件でフィルタ|[※](#where)|
|複数要素|[Distinct]|一意のコレクションを取得|[※](#distinct)|
|複数要素|[Skip]<br>[SkipWhile]|指定位置からのコレクションを取得|[※](#skip--skipwhile)|
|複数要素|[Take]<br>[TakeWhile]|指定数のコレクションを取得|[※](#take--takewhile)|
|複数要素|[DefaultIfEmpty]|コレクションが空の場合に既定値を取得|[※](#defaultifempty)|
|||||
|射影|[Select]|変換|[※](#select)|
|射影|[SelectMany]|平坦化|[※](#selectmany)|
|射影|[GroupBy]|グループ化|[※](#groupby)|
|||||
|結合|[Concat]|連結|[※](#concat)|
|結合|[Join]|結合|[※](#join)|
|結合|[GroupJoin]|グループ化|[※](#groupjoin)|
|||||
|並替|[Reverse]|反転|[※](#reverse)|
|並替|[OrderBy]<br>[OrderByDescending]|昇順or降順ソート|[※](#orderby--orderbydescending)|
|並替|[ThenBy]<br>[ThenByDescending]|昇順or降順ソート|[※](#thenby--thenbydescending)|
|||||
|集合|[Union]|和集合|[※](#union)|
|集合|[Except]|差集合|[※](#except)|
|集合|[Intersect]|積集合|[※](#intersect)|
|||||
|統計|[Count]|要素数を取得|[※](#count)|
|統計|[Max]|最大値を取得|[※](#max)|
|統計|[Min]|最小値を取得|[※](#min)|
|統計|[Sum]|合計値を計算|[※](#sum)|
|統計|[Average]|平均値を計算|[※](#average)|
|統計|[Aggregate]|アキュムレータ関数|[※](#aggregate)|

<!------------------------------------------------------>
## 生成

### Empty
```C#
var result = Enumerable.Empty<int>(); // ⇒ 空の IEnumerable<int>
```

### Repeat
```C#
var result = Enumerable.Repeat(1, 3); // ⇒ { 1, 1, 1 }
```

### Range
```C#
var result = Enumerable.Range(2, 4); // ⇒ { 2, 3, 4, 5 }
```

<!------------------------------------------------------>
## 変換

### AsEnumerable
LINQ と同じ名前のメソッドがあり、LINQ のメソッドを呼ぶ場合に使用する。

```C#
var list = new List<int>();
var result1 = list.Reverse(); // List<T>.Reverse() が呼ばれる
var result2 = list.AsEnumerable().Reverse(); // Enumerable.Reverse<T>() が呼ばれる
```

### Cast
```C#
var table = new System.Data.DataTable();
var rows = table.Rows.Cast<DataRow>(); // ⇒ IEnumerable<DataRow>
```

### ToArray
```C#
var source = new[] { 1, 2, 3, 4 };
var result = source.ToArray(); // ⇒ int[4]
```

### ToList
```C#
var source = new[] { 1, 2, 3, 4 };
var result = source.ToList(); // ⇒ List<int>
```

### ToDictionary
```C#
var source = new[] { 1, 2, 3, 4 };
var result = source.ToDictionary(item => item, item => item.ToString()); // ⇒ Dictionary<int, string>
```

### ToLookup
Dictionary&lt;TKey, IEnumerable&lt;TValue&gt;&gt; のような型に変換する。

```C#
enum Week { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };
var weeks = Enum.GetValues(typeof(Week)).Cast<Week>();

var result = dictionary.ToLookup(item => item.Value[0], item => item.Key);
// ⇒ 'S': { Sunday, Saturday }
// 　 'M': { Monday }
// 　 'T': { Tuesday, Thursday }
// 　 'W': { Wednesday }
// 　 'F': { Friday }
```

<!------------------------------------------------------>
## 判定

### Contains
```C#
var source = new[] { 0, 1, 1, 2, 3, 5, 8, 13 };
var result = source.Contains(1); // ⇒ true
```

### All
```C#
var source = new[] { 0, 1, 1, 2, 3, 5, 8, 13 };
var result = source.All(item => item < 10); // ⇒ false
```

### Any
```C#
var source = new[] { 0, 1, 1, 2, 3, 5, 8, 13 };
var result = source.Any(item => item < 10); // ⇒ true
```

### SequenceEqual
```C#
var source = new[] { 0, 1, 1 };
var result = source.SequenceEqual(new[] { 0, 1 }); // ⇒ false
var result = source.SequenceEqual(new[] { 0, 1, 1 }); // ⇒ true
```

<!------------------------------------------------------>
## 単一要素

### ElementAt / ElementAtOrDefault
```C#
var source = new[] { 1, 2, 3 };
var result = source.ElementAt(2); // ⇒ 3
var result = source.ElementAt(-1); // ⇒ ArgumentOutOfRangeException
var result = source.ElementAtOrDefault(-1); // ⇒ 0
```

### Single / SingleOrDefault
```C#
var source = new[] { 0, 1, 1, 2, 3, 5, 8, 13 };
var result = source.SingleOrDefault(item => item < 1); // ⇒ 0
var result = source.SingleOrDefault(item => item < 2); // ⇒ InvalidOperationException
```

### First / FirstOrDefault
```C#
var source = new[] { 0, 1, 1, 2, 3, 5, 8, 13 };
var result = source.First(item => item < 4); // ⇒ 0
```

### Last / LastOrDefault
```C#
var source = new[] { 0, 1, 1, 2, 3, 5, 8, 13 };
var result = source.Last(item => item < 4); // ⇒ 3
```

<!------------------------------------------------------>
## 複数要素

### OfType
```C#
var source = new object[] { 1, 2.4, 3, 4.7, 5 };
var result = source.OfType<int>(); // ⇒ { 1, 3, 5 }
```

### Where
```C#
// 作成中…
```

### Distinct
```C#
// 作成中…
```

### Skip / SkipWhile
```C#
var source = new[] { 1, 2, 3, 4, 5 };
var result = source.Skip(2); // ⇒ { 3, 4, 5 }
```

### Take / TakeWhile
```C#
var source = new[] { 1, 2, 3, 4, 5 };
var result = source.Take(2); // ⇒ { 1, 2 }
```

### DefaultIfEmpty
```C#
// 作成中…
```

<!------------------------------------------------------>
## 射影

### Select
```C#
var source = new[] { 1, 2, 3 }
var result = source.Select(item => item.ToString()); // ⇒ { "1", "2", "3" }
```

### SelectMany
```C#
// 作成中…
```

### GroupBy
```C#
// 作成中…
```

<!------------------------------------------------------>
## 結合

### Concat
```C#
// 作成中…
var source = new[] { 1, 2, 3 }
var result = source.Concat(new[] { 4, 5 }); // ⇒ { 1, 2, 3, 4, 5 }
```

### Join
```C#
// 作成中…
```

### GroupJoin
```C#
// 作成中…
```

<!------------------------------------------------------>
## 並替

### Reverse
```C#
var source = new[] { 1, 2, 3 };
var result = source.Reverse(); // ⇒ { 3, 2, 1 }
```

### OrderBy / OrderByDescending
```C#
// 作成中…
```

### ThenBy / ThenByDescending
```C#
// 作成中…
```

<!------------------------------------------------------>
## 集合

### Union
```C#
var source1 = new [] {10, 20, 30};
var source2 = new [] {20, 40, 15};
var result = source1.Union(source2); // ⇒ {10, 15, 20, 30, 40}
```

### Except
```C#
var source1 = new [] {10, 20, 30};
var source2 = new [] {20, 40, 15};
var result = source1.Except(source2); // ⇒ {10, 30}
```

### Intersect
```C#
var source1 = new [] {10, 20, 30};
var source2 = new [] {20, 40, 15};
var result = source1.Intersect(source2); // ⇒ {20}
```

<!------------------------------------------------------>
## 統計

### Count
```C#
var source = new[] { 0, 1, 2, 3 }
var result = source.Count(); // ⇒ 4
var result = source.Count(item => item <= 1); // ⇒ 2
```

### Max
```C#
var source = new[] { 0, 1, 2, 3 }
var result = source.Max(); // ⇒ 3
```

### Min
```C#
var source = new[] { 0, 1, 2, 3 }
var result = source.Min(); // ⇒ 0
```

### Sum
```C#
var source = new[] { 0, 1, 2, 3 }
var result = source.Sum(); // ⇒ 6
```

### Average
```C#
var source = new[] { 0, 1, 2, 3 }
var result = source.Average(); // ⇒ 1.5
```

### Aggregate
どのように集計するかの方法を指定する統計関数で、下記例では合計を計算するため Sum と同じ結果となる。

```C#
var source = new[] { 0, 1, 2, 3 }
var result = source.Aggregate((sum, item) => sum + item); // ⇒ 6
```

<!--references------------------------------------------>
[Aggregate]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.aggregate
[All]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.all
[Any]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.any
[AsEnumerable]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.asenumerable
[Average]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.average
[Cast]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.cast
[Concat]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.concat
[Contains]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.contains
[Count]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.count
[DefaultIfEmpty]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.defaultifempty
[Distinct]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.distinct
[ElementAt]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.elementat
[ElementAtOrDefault]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.elementatordefault
[Empty]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.empty
[Except]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.except
[First]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.first
[FirstOrDefault]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.firstordefault
[GroupBy]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.groupby
[GroupJoin]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.groupjoin
[Intersect]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.intersect
[Join]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.join
[Last]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.last
[LastOrDefault]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.lastordefault
[Max]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.max
[Min]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.min
[OfType]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.oftype
[OrderBy]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.orderby
[OrderByDescending]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.orderbydescending
[Range]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.range
[Repeat]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.repeat
[Reverse]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.reverse
[Select]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.select
[SelectMany]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.selectmany
[SequenceEqual]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.sequenceequal
[Single]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.single
[SingleOrDefault]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.singleordefault
[Skip]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.skip
[SkipWhile]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.skipwhile
[Sum]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.sum
[Take]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.take
[TakeWhile]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.takewhile
[ThenBy]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.thenby
[ThenByDescending]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.thenbydescending
[ToArray]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.toarray
[ToDictionary]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.todictionary
[ToList]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.tolist
[ToLookup]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.tolookup
[Union]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.union
[Where]: https://docs.microsoft.com/ja-jp/dotnet/api/system.linq.enumerable.where