LoginSignup
43
51

More than 5 years have passed since last update.

Linq 拡張メソッド一覧

Last updated at Posted at 2018-12-13

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
43
51
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
43
51