Linq 拡張メソッド一覧

System.Linq.Enumerable

コレクション (IEnumerable<T>) の拡張メソッドを分類

分類	名称	機能	例
生成	Empty	空のコレクションを取得	※
生成	Repeat	指定数のコレクションを取得	※
生成	Range	指定範囲の整数コレクションを取得	※
変換	AsEnumerable	IEnumerable<T> 型に変換	※
変換	Cast	要素を指定した型に変換 変換できない場合は例外	※
変換	ToArray	配列に変換	※
変換	ToList	リストに変換	※
変換	ToDictionary	ディクショナリに変換	※
変換	ToLookup	分類	※
判定	Contains	要素を含んでいるか判断	※
判定	All	すべての要素が条件を満たしているか判断	※
判定	Any	どれかの要素が条件を満たしているか判断	※
判定	SequenceEqual	要素が等しいか判断	※
単一要素	ElementAt ElementAtOrDefault	指定位置の要素を取得	※
単一要素	Single SingleOrDefault	単一の要素を取得 複数ある場合は例外or既定値	※
単一要素	First FirstOrDefault	最初の要素を取得 見つからない場合は例外or既定値	※
単一要素	Last LastOrDefault	最後の要素を取得 見つからない場合は例外or既定値	※
複数要素	OfType	指定した型でフィルタ	※
複数要素	Where	指定した条件でフィルタ	※
複数要素	Distinct	一意のコレクションを取得	※
複数要素	Skip SkipWhile	指定位置からのコレクションを取得	※
複数要素	Take TakeWhile	指定数のコレクションを取得	※
複数要素	DefaultIfEmpty	コレクションが空の場合に既定値を取得	※
射影	Select	変換	※
射影	SelectMany	平坦化	※
射影	GroupBy	グループ化	※
結合	Concat	連結	※
結合	Join	結合	※
結合	GroupJoin	グループ化	※
並替	Reverse	反転	※
並替	OrderBy OrderByDescending	昇順or降順ソート	※
並替	ThenBy ThenByDescending	昇順or降順ソート	※
集合	Union	和集合	※
集合	Except	差集合	※
集合	Intersect	積集合	※
統計	Count	要素数を取得	※
統計	Max	最大値を取得	※
統計	Min	最小値を取得	※
統計	Sum	合計値を計算	※
統計	Average	平均値を計算	※
統計	Aggregate	アキュムレータ関数	※

生成

Empty

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

Repeat

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

Range

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

変換

AsEnumerable

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

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

Cast

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

ToArray

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

ToList

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

ToDictionary

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

ToLookup

Dictionary<TKey, IEnumerable<TValue>> のような型に変換する。

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

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

All

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

Any

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

SequenceEqual

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

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

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

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

Last / LastOrDefault

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

複数要素

OfType

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

Where

// 作成中…

Distinct

// 作成中…

Skip / SkipWhile

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

Take / TakeWhile

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

DefaultIfEmpty

// 作成中…

射影

Select

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

SelectMany

// 作成中…

GroupBy

// 作成中…

結合

Concat

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

Join

// 作成中…

GroupJoin

// 作成中…

並替

Reverse

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

OrderBy / OrderByDescending

// 作成中…

ThenBy / ThenByDescending

// 作成中…

集合

Union

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

Except

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

Intersect

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

統計

Count

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

Max

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

Min

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

Sum

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

Average

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

Aggregate

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

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