.NET Framework
LINQ

ASP.NET asp.net-mvc C# Language Entity Framework JavaScript Regular Expressions SQL Microsoft SQL Server Visual Basic .NET Language wpf
サーチ…


前書き

LINQ（Language Integrated Query）は、データソースからデータを取得する式です。 LINQは、さまざまな種類のデータソースおよび形式にわたるデータを処理するための一貫したモデルを提供することで、この状況を簡素化します。 LINQクエリでは、常にオブジェクトで作業しています。同じ基本コーディングパターンを使用して、XML文書、SQLデータベース、ADO.NETデータセット、.NETコレクション、およびプロバイダーが利用可能なその他の形式のデータを照会および変換します。 LINQはC＃とVBで使用できます。

構文

  • public static TSource集計<TSource>（このIEnumerable <TSource>ソース、Func <TSource、TSource、TSource> func）
  • public static TAccumulate Aggregate <TSource、TAccumulate>（このIEnumerable <TSource>ソース、TAccumulateシード、Func <TAccumulate、TSource、TAccumulate>関数）
  • public static TResult Aggregate <TSource、TAccumulate、TResult>（このIEnumerable <TSource>ソース、TAccumulateシード、Func <TAccumulate、TSource、TAccumulate> func、Func <TAccumulate、TResult> resultSelector）
  • public static Booleanすべての<TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public static Boolean任意の<TSource>（このIEnumerable <TSource>ソース）
  • public static Boolean任意の<TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public static IEnumerable <TSource> AsEnumerable <TSource>（このIEnumerable <TSource>ソース）
  • public static Decimal Average（このIEnumerable <Decimal>ソース）
  • public static Double Average（このIEnumerable <Double>ソース）
  • public static Double Average（このIEnumerable <Int32>ソース）
  • public static Double Average（このIEnumerable <Int64>ソース）
  • public static Nullable <Decimal> Average（このIEnumerable <Nullable <Decimal >>ソース）
  • public static Nullable <Double> Average（このIEnumerable <Nullable <Double >>ソース）
  • public static Nullable <Double> Average（このIEnumerable <Nullable <Int32 >>ソース）
  • public static Nullable <Double> Average（このIEnumerable <Nullable <Int64 >>ソース）
  • public static Nullable <Single> Average（このIEnumerable <Nullable <Single >>ソース）
  • public static Single Average（このIEnumerable <Single>ソース）
  • public static Decimal Average <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Decimal>セレクタ）
  • public static Double <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Double>セレクタ）
  • public static Double Average <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Int32>セレクタ）
  • public static Double Average <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Int64>セレクタ）
  • public static Nullable <Decimal> Average <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Decimal >>セレクタ）
  • パブリックstatic Nullable <Double> Average <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Double >>セレクタ）
  • public static Nullable <Double> Average <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Int32 >>セレクタ）
  • public static Nullable <Double> Average <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Int64 >>セレクタ）
  • public static Nullable <Single> Average <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Single >>セレクタ）
  • public static Single Average <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Single>セレクタ）
  • public static IEnumerable <TResult>キャスト<TResult>（このIEnumerableソース）
  • public static IEnumerable <TSource> Concat <TSource>（このIEnumerable <TSource>が最初、IEnumerable <TSource>がsecond）
  • public static Boolean <TSource>（このIEnumerable <TSource>ソース、TSource値）
  • public static Boolean <TSource>（このIEnumerable <TSource>ソース、TSource値、IEqualityComparer <TSource>コンペアラ）
  • public static Int32 Count <TSource>（このIEnumerable <TSource>ソース）
  • public static Int32 Count <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource>（このIEnumerable <TSource>ソース）
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource>（このIEnumerable <TSource>ソース、TSource defaultValue）
  • public static IEnumerable <TSource> Distinct <TSource>（このIEnumerable <TSource>ソース）
  • public static IEnumerable <TSource> Distinct <TSource>（このIEnumerable <TSource>ソース、IEqualityComparer <TSource> comparer）
  • public static TSource ElementAt <TSource>（このIEnumerable <TSource>ソース、Int32インデックス）
  • public static TSource ElementAtOrDefault <TSource>（このIEnumerable <TSource>ソース、Int32インデックス）
  • public static IEnumerable <TResult> Empty <TResult>（）
  • public static IEnumerable <TSource> <TSource>を除く（このIEnumerable <TSource>が最初、IEnumerable <TSource>がsecond）
  • public static IEnumerable <TSource> <TSource>を除く（このIEnumerable <TSource>最初、IEnumerable <TSource> second、IEqualityComparer <TSource> comparer）
  • public static TSource最初の<TSource>（このIEnumerable <TSource>ソース）
  • public static TSource最初の<TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public static TSource FirstOrDefault <TSource>（このIEnumerable <TSource>ソース）
  • public static TSource FirstOrDefault <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public IEnumerable <IGrouping <TKey、TSource >> GroupBy <TSource、TKey>（このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector）
  • このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、IEqualityComparer <TKey> comparer）は、IEnumerable <IGKeying <TKey、TSource >> GroupBy <TSource、TKey>
  • このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、Func <TSource、TElement> elementSelector）この静的メソッドは、IEnumerable <IGKeying <TKey、TElement>、GroupBy <TSource、TKey、TElement>
  • このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、Func <TSource、TElement> elementSelector、IEqualityComparer <TKey> comparer）パブリックstatic IEnumerable <IGrouping <TKey、TElement >> GroupBy <TSource、TKey、TElement>
  • このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、Func <TKey、IEnumerable <TSource>、TResult> resultSelector）を使用して、IEnumerable <TResult>
  • このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、Func <TKey、IEnumerable <TSource>、TResult> resultSelector、IEqualityComparer <TKey>コンストラクタ）
  • このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、Func <TSource、TElement> elementSelector、Func <TKey、IEnumerable <TElement>、TResult > resultSelector）
  • このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、Func <TSource、TElement> elementSelector、Func <TKey、IEnumerable <TElement>、TResult > resultSelector、IEqualityComparer <TKey> comparer）
  • IEnumerable <TOuter>外部、IEnumerable <TInner>内部、Func <TOuter、TKey>外部キーセレクタ、Func <TInner、TKey>内部キーセレクタ、Func <TOuter、 IEnumerable <TInner>、TResult> resultSelector）
  • IEnumerable <TOuter>外部、IEnumerable <TInner>内部、Func <TOuter、TKey>外部キーセレクタ、Func <TInner、TKey>内部キーセレクタ、Func <TOuter、 IEnumerable <TInner>、TResult> resultSelector、IEqualityComparer <TKey> comparer）
  • public static IEnumerable <TSource> Intersect <TSource>（このIEnumerable <TSource>が最初、IEnumerable <TSource>がsecond）
  • public static IEnumerable <TSource> Intersect <TSource>（このIEnumerable <TSource>が最初、IEnumerable <TSource>がsecond、IEqualityComparer <TSource>が比較元）
  • IEnumerable <TOuter>外部、IEnumerable <TInner>内部、Func <TOuter、TKey> outerKeySelector、Func <TInner、TKey> innerKeySelector、Func <TOuter、TKey、TResult> TInner、TResult> resultSelector）
  • IEnumerable <TOuter>外部、IEnumerable <TInner>内部、Func <TOuter、TKey> outerKeySelector、Func <TInner、TKey> innerKeySelector、Func <TOuter、TKey、TResult> TInner、TResult> resultSelector、IEqualityComparer <TKey> comparer）
  • public static TSource Last <TSource>（このIEnumerable <TSource>ソース）
  • public static TSource Last <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public static TSource LastOrDefault <TSource>（このIEnumerable <TSource>ソース）
  • public static TSource LastOrDefault <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public static Int64 LongCount <TSource>（このIEnumerable <TSource>ソース）
  • public static Int64 LongCount <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public static Decimal Max（このIEnumerable <Decimal>ソース）
  • public static Double Max（このIEnumerable <Double>ソース）
  • public static Int32 Max（このIEnumerable <Int32>ソース）
  • public static Int64 Max（このIEnumerable <Int64>ソース）
  • public static Nullable <Decimal> Max（このIEnumerable <Nullable <Decimal >>ソース）
  • public static Nullable <Double> Max（このIEnumerable <Nullable <Double >>ソース）
  • public static Nullable <Int32> Max（このIEnumerable <Nullable <Int32 >>ソース）
  • public static Nullable <Int64> Max（このIEnumerable <Nullable <Int64 >>ソース）
  • public static Nullable <Single> Max（このIEnumerable <Nullable <Single >>ソース）
  • public static Single Max（このIEnumerable <Single>ソース）
  • public static TSource Max <TSource>（このIEnumerable <TSource>ソース）
  • public static Decimal Max <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Decimal>セレクタ）
  • public static Double Max <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Double>セレクタ）
  • public static Int32 Max <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Int32>セレクタ）
  • public static Int64 Max <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Int64>セレクタ）
  • パブリックstatic Nullable <Decimal> Max <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Decimal >>セレクタ）
  • public static Nullable <Double> Max <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Double >>セレクタ）
  • public static Nullable <Int32> Max <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Int32 >>セレクタ）
  • public static Nullable <Int64> Max <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Int64 >>セレクタ）
  • public static Nullable <Single> Max <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Single >>セレクタ）
  • public static Single Max <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Single>セレクタ）
  • public static TResult Max <TSource、TResult>（このIEnumerable <TSource>ソース、Func <TSource、TResult>セレクタ）
  • public static Decimal Min（このIEnumerable <Decimal>ソース）
  • public static Double Min（このIEnumerable <Double>ソース）
  • public static Int32 Min（このIEnumerable <Int32>ソース）
  • public static Int64 Min（このIEnumerable <Int64>ソース）
  • public static Nullable <Decimal> Min（このIEnumerable <Nullable <Decimal >>ソース）
  • public static Nullable <Double> Min（このIEnumerable <Nullable <Double >>ソース）
  • public static Nullable <Int32> Min（このIEnumerable <Nullable <Int32 >>ソース）
  • public static Nullable <Int64> Min（このIEnumerable <Nullable <Int64 >>ソース）
  • public static Nullable <Single> Min（このIEnumerable <Nullable <Single >>ソース）
  • public static Single Min（このIEnumerable <Single>ソース）
  • public static TSource Min <TSource>（このIEnumerable <TSource>ソース）
  • public static Decimal Min <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Decimal>セレクタ）
  • public static Double Min <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Double>セレクタ）
  • public static Int32 Min <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Int32>セレクタ）
  • public static Int64 Min <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Int64>セレクタ）
  • public static Nullable <Decimal> Min <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Decimal >>セレクタ）
  • public static Nullable <Double> Min <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Double >>セレクタ）
  • public static Nullable <Int32> Min <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Int32 >>セレクタ）
  • public static Nullable <Int64> Min <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Int64 >>セレクタ）
  • public static Nullable <Single> Min <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Single >>セレクタ）
  • public static Single Min <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Single>セレクタ）
  • public static TResult Min <TSource、TResult>（このIEnumerable <TSource>ソース、Func <TSource、TResult>セレクタ）
  • public static IEnumerable <TResult> OfType <TResult>（このIEnumerableソース）
  • パブリック静的IOrderedEnumerable <TSource> OrderBy <TSource、TKey>（このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector）
  • パブリック静的IOrderedEnumerable <TSource> OrderBy <TSource、TKey>（このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、IComparer <TKey> comparer）
  • パブリック静的IOrderedEnumerable <TSource> OrderByDescending <TSource、TKey>（このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector）
  • パブリック静的IOrderedEnumerable <TSource> OrderByDescending <TSource、TKey>（このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、IComparer <TKey> comparer）
  • パブリック静的IEnumerable <Int32>範囲（Int32開始、Int32カウント）
  • public static IEnumerable <TResult>繰り返し<TResult>（TResult要素、Int32カウント）
  • public static IEnumerable <TSource> Reverse <TSource>（このIEnumerable <TSource>ソース）
  • public static IEnumerable <TResult> <TSource、TResult>（このIEnumerable <TSource>ソース、Func <TSource、TResult>セレクタ）を選択します。
  • public static IEnumerable <TResult> <TSource、TResult>（このIEnumerable <TSource>ソース、Func <TSource、Int32、TResult>セレクタ）を選択します。
  • public static IEnumerable <TResult> SelectMany <TSource、TResult>（このIEnumerable <TSource>ソース、Func <TSource、IEnumerable <TResult >>セレクタ）
  • public IEnumerable <TResult> SelectMany <TSource、TResult>（このIEnumerable <TSource>ソース、Func <TSource、Int32、IEnumerable <TResult >>セレクタ）
  • public IEnumerable <TResult> SelectMany <TSource、TCollection、TResult>（このIEnumerable <TSource>ソース、Func <TSource、IEnumerable <TCollection >> collectionSelector、Func <TSource、TCollection、TResult> resultSelector）
  • このIEnumerable <TSource>ソース、Func <TSource、Int32、IEnumerable <TCollection >> collectionSelector、Func <TSource、TCollection、TResult> resultSelector）パブリックstatic IEnumerable <TResult> SelectMany <TSource、TCollection、TResult>
  • public static Boolean SequenceEqual <TSource>（このIEnumerable <TSource>が最初、IEnumerable <TSource>がsecond）
  • public static Boolean SequenceEqual <TSource>（このIEnumerable <TSource> first、IEnumerable <TSource> second、IEqualityComparer <TSource> comparer）
  • public static TSource Single <TSource>（このIEnumerable <TSource>ソース）
  • public static TSource Single <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public static TSource SingleOrDefault <TSource>（このIEnumerable <TSource>ソース）
  • public static TSource SingleOrDefault <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public static IEnumerable <TSource> Skip <TSource>（このIEnumerable <TSource>ソース、Int32カウント）
  • public static IEnumerable <TSource> SkipWhile <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public static IEnumerable <TSource> SkipWhile <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Int32、Boolean>述語）
  • public static Decimal Sum（このIEnumerable <Decimal>ソース）
  • public static Double Sum（このIEnumerable <Double>ソース）
  • public static Int32 Sum（このIEnumerable <Int32>ソース）
  • public static Int64 Sum（このIEnumerable <Int64>ソース）
  • public static Nullable <Decimal> Sum（このIEnumerable <Nullable <Decimal >>ソース）
  • public static Nullable <Double> Sum（このIEnumerable <Nullable <Double >>ソース）
  • public static Nullable <Int32> Sum（このIEnumerable <Nullable <Int32 >>ソース）
  • public static Nullable <Int64> Sum（このIEnumerable <Nullable <Int64 >>ソース）
  • public static Nullable <Single> Sum（このIEnumerable <Nullable <Single >>ソース）
  • public static Single Sum（このIEnumerable <Single>ソース）
  • public static Decimal Sum <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Decimal>セレクタ）
  • public static Double Sum <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Double>セレクタ）
  • public static Int32 Sum <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Int32>セレクタ）
  • public static Int64 Sum <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Int64>セレクタ）
  • パブリックstatic Nullable <Decimal> Sum <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Decimal >>セレクタ）
  • パブリックstatic Nullable <Double> Sum <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Double >>セレクタ）
  • public static Nullable <Int32> Sum <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Int32 >>セレクタ）
  • public static Nullable <Int64> Sum <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Int64 >>セレクタ）
  • パブリックstatic Nullable <Single> Sum <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Nullable <Single >>セレクタ）
  • public static Single Sum <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Single>セレクタ）
  • public static IEnumerable <TSource> Take <TSource>（このIEnumerable <TSource>ソース、Int32カウント）
  • public static IEnumerable <TSource> TakeWhile <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • パブリック静的IEnumerable <TSource> TakeWhile <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Int32、Boolean>述語）
  • public static IOrderedEnumerable <TSource> ThenBy <TSource、TKey>（このIOrderedEnumerable <TSource>ソース、Func <TSource、TKey> keySelector）
  • public static IOrderedEnumerable <TSource> ThenBy <TSource、TKey>（このIOrderedEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、IComparer <TKey> comparer）
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource、TKey>（このIOrderedEnumerable <TSource>ソース、Func <TSource、TKey> keySelector）
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource、TKey>（このIOrderedEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、IComparer <TKey> comparer）
  • public static TSource [] ToArray <TSource>（このIEnumerable <TSource>ソース）
  • public static Dictionary <TKey、TSource> ToDictionary <TSource、TKey>（このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector）
  • このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、IEqualityComparer <TKey>コンストラクタ）
  • このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、Func <TSource、TElement> elementSelector）パブリックstatic Dictionary <TKey、TElement> ToDictionary <TSource、TKey、TElement>
  • このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、Func <TSource、TElement> elementSelector、IEqualityComparer <TKey> comparer）
  • public static List <TSource> ToList <TSource>（このIEnumerable <TSource>ソース）
  • public static ILookup <TKey、TSource> ToLookup <TSource、TKey>（このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector）
  • public static ILookup <TKey、TSource> ToLookup <TSource、TKey>（このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、IEqualityComparer <TKey> comparer）
  • パブリックstatic ILookup <TKey、TElement> ToLookup <TSource、TKey、TElement>（このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、Func <TSource、TElement> elementSelector）
  • このIEnumerable <TSource>ソース、Func <TSource、TKey> keySelector、Func <TSource、TElement> elementSelector、IEqualityComparer <TKey> comparer）パブリックstatic ILookup <TKey、TElement> ToLookup <TSource、TKey、TElement>
  • public static IEnumerable <TSource> Union <TSource>（このIEnumerable <TSource>が最初、IEnumerable <TSource>がsecond）
  • public static IEnumerable <TSource> Union <TSource>（このIEnumerable <TSource> first、IEnumerable <TSource> second、IEqualityComparer <TSource> comparer）
  • public static IEnumerable <TSource> <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Boolean>述語）
  • public static IEnumerable <TSource> <TSource>（このIEnumerable <TSource>ソース、Func <TSource、Int32、Boolean>述語）
  • public static IEnumerable <TResult> Zip <TFirst、TSecond、TResult>（このIEnumerable <TFirst> first、IEnumerable <TSecond> second、Func <TFirst、TSecond、TResult> resultSelector）

備考

  • LINQも参照してください。

LINQビルトインメソッドは、 System.CoreアセンブリのSystem.Linq.Enumerableクラスに存在するIEnumerable<T>インターフェイスの拡張メソッドです。これらは.NET Framework 3.5以降で使用できます。

LINQでは、クエリのような構文や関数構文を使用して、さまざまなIEnumerableを簡単に変更、変換、および組み合わせることができます。

標準のLINQメソッドは、単純な配列やList<T>を含む任意のIEnumerable<T>で動作することができますが、LINQ式のセットをSQLに変換できるデータベースオブジェクトでも使用できます。データオブジェクトはそれをサポートします。 LINQ to SQLを参照してください。

オブジェクト（ ContainsやExceptなど）を比較するメソッドでは、コレクションの型Tがそのインタフェースを実装する場合、 IEquatable<T>.Equalsが使用されます。それ以外の場合は、型の標準のEqualsおよびGetHashCode （デフォルトのObject実装からオーバーライドされる可能性があります）が使用されます。カスタムIEqualityComparer<T>を指定できるこれらのメソッドのオーバーロードもあります。

...OrDefaultメソッドの場合、 default(T)がデフォルト値を生成するために使用されます。

公式のリファレンス： Enumerableクラス

レイジー評価

IEnumerable<T>を返すすべてのクエリは、直ちに評価されません。代わりに、クエリが反復されるまでロジックが遅延します。 1つの意味は、誰かがこれらのクエリーの1つ、たとえば.Where()から作成したIEnumerable<T>反復処理するたびに、完全なクエリーロジックが繰り返されることです。述部が長時間実行されている場合、これはパフォーマンス上の問題の原因になります。

1つの簡単な解決法（結果のシーケンスのおおよそのサイズを知っているか、または制御できる場合）は、 .ToArray()または.ToList()を使用して結果を完全にバッファリングすることです。 .ToDictionary()または.ToLookup()は同じ役割を果たすことができます。もちろん、シーケンス全体を反復して、他のカスタムロジックに従って要素をバッファすることもできます。

ToArray()またはToList() ？

.ToArray()と.ToList()は、 IEnumerable<T>シーケンスのすべての要素をループし、その結果をメモリに格納されたコレクションに保存します。どちらを選択するかは、次のガイドラインを参考にしてください。

  • いくつかのAPIはT[]またはList<T>必要とするかもしれません。
  • .ToList()は通常、より高速に動作し、 .ToArray()よりも少ないゴミを生成します。後者は、すべての要素を新しい固定サイズのコレクションにコピーする必要があります。
  • 要素が追加またはから除去することができるList<T>によって返さ.ToList()一方、 T[]から返さ.ToArray()その生涯を通じて固定サイズのままです。つまり、 List<T>は変更可能であり、 T[]は不変です。
  • T[]から返さ.ToArray()より少ないメモリを使用するList<T>から返さ.ToList()結果は長期間保存されようとしているので、もし、好む.ToArray() 。呼び出しList<T>.TrimExcess()は、メモリの違いを厳密にアカデミックにしますが、 .ToList()相対的な速度の優位性を排除します。

選択（地図）

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var names = persons.Select(p => p.Name);
Console.WriteLine(string.Join(",", names.ToArray()));

//Foo,Bar,Fizz,Buzz

このタイプの関数は、通常、関数型プログラミング言語ではmapと呼ばれmap 。

どこ（フィルタ）

このメソッドは、ラムダ式を満たすすべての要素を含むIEnumerableを返します。

例 

var personNames = new[] 
{
    "Foo", "Bar", "Fizz", "Buzz"
};

var namesStartingWithF = personNames.Where(p => p.StartsWith("F"));
Console.WriteLine(string.Join(",", namesStartingWithF));

出力：

フー、フィッツ

デモを見る

OrderBy

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var personsSortedByName = persons.OrderBy(p => p.Name);

Console.WriteLine(string.Join(",", personsSortedByName.Select(p => p.Id).ToArray()));

//2,4,3,1

OrderByDescending

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var personsSortedByNameDescending = persons.OrderByDescending(p => p.Name);

Console.WriteLine(string.Join(",", personsSortedByNameDescending.Select(p => p.Id).ToArray()));

//1,3,4,2

含有

var numbers = new[] {1,2,3,4,5};
Console.WriteLine(numbers.Contains(3)); //True
Console.WriteLine(numbers.Contains(34)); //False

例外

var numbers = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var evenNumbersBetweenSixAndFourteen = new[] { 6, 8, 10, 12 };

var result = numbers.Except(evenNumbersBetweenSixAndFourteen);

Console.WriteLine(string.Join(",", result));

//1, 2, 3, 4, 5, 7, 9

交差点

var numbers1to10 = new[] {1,2,3,4,5,6,7,8,9,10};
var numbers5to15 = new[] {5,6,7,8,9,10,11,12,13,14,15};

var numbers5to10 = numbers1to10.Intersect(numbers5to15);

Console.WriteLine(string.Join(",", numbers5to10));

//5,6,7,8,9,10

連合

var numbers1to5 = new[] {1, 2, 3, 4, 5};
var numbers4to8 = new[] {4, 5, 6, 7, 8};

var numbers1to8 = numbers1to5.Concat(numbers4to8);

Console.WriteLine(string.Join(",", numbers1to8));

//1,2,3,4,5,4,5,6,7,8

結果に重複が残っていることに注意してください。これが望ましくない場合は、代わりにUnion使用してください。

最初（見つける）

var numbers = new[] {1,2,3,4,5};

var firstNumber = numbers.First();
Console.WriteLine(firstNumber); //1

var firstEvenNumber = numbers.First(n => (n & 1) == 0);
Console.WriteLine(firstEvenNumber); //2

InvalidOperationExceptionが "シーケンスに一致する要素が含まれていません"というメッセージがスローされます。 

var firstNegativeNumber = numbers.First(n => n < 0);

シングル

var oneNumber = new[] {5};
var theOnlyNumber = oneNumber.Single();
Console.WriteLine(theOnlyNumber);  //5

var numbers = new[] {1,2,3,4,5};

var theOnlyNumberSmallerThanTwo = numbers.Single(n => n < 2);
Console.WriteLine(theOnlyNumberSmallerThanTwo);  //1

シーケンス内に複数の要素があるため、次のInvalidOperationExceptionはInvalidOperationExceptionスローします。 

var theOnlyNumberInNumbers = numbers.Single();
var theOnlyNegativeNumber = numbers.Single(n => n < 0);

最終

var numbers = new[] {1,2,3,4,5};

var lastNumber = numbers.Last();
Console.WriteLine(lastNumber); //5

var lastEvenNumber = numbers.Last(n => (n & 1) == 0);
Console.WriteLine(lastEvenNumber); //4

InvalidOperationExceptionスローされる： 

var lastNegativeNumber = numbers.Last(n => n < 0);

LastOrDefault

var numbers = new[] {1,2,3,4,5};

var lastNumber = numbers.LastOrDefault();
Console.WriteLine(lastNumber); //5

var lastEvenNumber = numbers.LastOrDefault(n => (n & 1) == 0);
Console.WriteLine(lastEvenNumber); //4

var lastNegativeNumber = numbers.LastOrDefault(n => n < 0);
Console.WriteLine(lastNegativeNumber); //0

var words = new[] { "one", "two", "three", "four", "five" };

var lastWord = words.LastOrDefault();
Console.WriteLine(lastWord); // five

var lastLongWord = words.LastOrDefault(w => w.Length > 4);
Console.WriteLine(lastLongWord); // three

var lastMissingWord = words.LastOrDefault(w => w.Length > 5);
Console.WriteLine(lastMissingWord); // null

SingleOrDefault

var oneNumber = new[] {5};
var theOnlyNumber = oneNumber.SingleOrDefault();
Console.WriteLine(theOnlyNumber);  //5

var numbers = new[] {1,2,3,4,5};

var theOnlyNumberSmallerThanTwo = numbers.SingleOrDefault(n => n < 2);
Console.WriteLine(theOnlyNumberSmallerThanTwo);  //1

var theOnlyNegativeNumber = numbers.SingleOrDefault(n => n < 0);
Console.WriteLine(theOnlyNegativeNumber);  //0

InvalidOperationExceptionスローされる： 

var theOnlyNumberInNumbers = numbers.SingleOrDefault();

FirstOrDefault

var numbers = new[] {1,2,3,4,5};

var firstNumber = numbers.FirstOrDefault();
Console.WriteLine(firstNumber); //1

var firstEvenNumber = numbers.FirstOrDefault(n => (n & 1) == 0);
Console.WriteLine(firstEvenNumber); //2

var firstNegativeNumber = numbers.FirstOrDefault(n => n < 0);
Console.WriteLine(firstNegativeNumber); //0

var words = new[] { "one", "two", "three", "four", "five" };

var firstWord = words.FirstOrDefault();
Console.WriteLine(firstWord); // one

var firstLongWord = words.FirstOrDefault(w => w.Length > 3);
Console.WriteLine(firstLongWord); // three

var firstMissingWord = words.FirstOrDefault(w => w.Length > 5);
Console.WriteLine(firstMissingWord); // null

どれか

コレクションにラムダ式の条件を満たす要素がtrue場合はtrue返します。 

var numbers = new[] {1,2,3,4,5};

var isNotEmpty = numbers.Any();
Console.WriteLine(isNotEmpty); //True

var anyNumberIsOne = numbers.Any(n => n == 1);
Console.WriteLine(anyNumberIsOne); //True

var anyNumberIsSix = numbers.Any(n => n == 6);
Console.WriteLine(anyNumberIsSix); //False    

var anyNumberIsOdd = numbers.Any(n => (n & 1) == 1);
Console.WriteLine(anyNumberIsOdd); //True

var anyNumberIsNegative = numbers.Any(n => n < 0);
Console.WriteLine(anyNumberIsNegative); //False

すべて

var numbers = new[] {1,2,3,4,5};

var allNumbersAreOdd = numbers.All(n => (n & 1) == 1);
Console.WriteLine(allNumbersAreOdd); //False

var allNumbersArePositive = numbers.All(n => n > 0);
Console.WriteLine(allNumbersArePositive); //True

Allメソッドは、述語に従ってfalseと評価される最初の要素をチェックすることによって機能することに注意してください。したがって、このメソッドは、セットが空の場合にはどの述語でも trueを返しtrue 。 

var numbers = new int[0];
var allNumbersArePositive = numbers.All(n => n > 0);
Console.WriteLine(allNumbersArePositive); //True

SelectMany（フラットマップ）

Enumerable.Selectはすべての入力要素の出力要素を返しEnumerable.Select 。 Enumerable.SelectManyは入力要素ごとに可変数の出力要素を生成します。これは、出力シーケンスに入力シーケンスよりも多くの要素が含まれる可能性があることを意味します。

Enumerable.Select渡されるLambda expressionsは、単一の項目を返す必要があります。 Enumerable.SelectMany渡されるラムダ式は、子シーケンスを生成する必要がありEnumerable.SelectMany 。この子シーケンスには、入力シーケンス内の各要素に対してさまざまな数の要素を含めることができます。

例 

class Invoice
{
    public int Id { get; set; }
}

class Customer
{
    public Invoice[] Invoices {get;set;}
}

var customers = new[] {
    new Customer {
        Invoices = new[] {
            new Invoice {Id=1},
            new Invoice {Id=2},
        }
    },
    new Customer {
        Invoices = new[] {
            new Invoice {Id=3},
            new Invoice {Id=4},
        }
    },
    new Customer {
        Invoices = new[] {
            new Invoice {Id=5},
            new Invoice {Id=6},
        }
    }
};

var allInvoicesFromAllCustomers = customers.SelectMany(c => c.Invoices);

Console.WriteLine(
    string.Join(",", allInvoicesFromAllCustomers.Select(i => i.Id).ToArray()));

出力：

1,2,3,4,5,6

デモを見る

Enumerable.SelectManyは、2つの連続したfrom節を使用する構文ベースのクエリでも実現できEnumerable.SelectMany 。 

var allInvoicesFromAllCustomers
    = from customer in customers
      from invoice in customer.Invoices
      select invoice;

和

var numbers = new[] {1,2,3,4};

var sumOfAllNumbers = numbers.Sum();
Console.WriteLine(sumOfAllNumbers); //10

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var totalPopulation = cities.Sum(c => c.Population);
Console.WriteLine(totalPopulation); //7500

スキップ

Skipは最初のN個のアイテムを返さずに列挙します。アイテム番号N + 1に達すると、Skipはすべての列挙アイテムを返すようになります。 

var numbers = new[] {1,2,3,4,5};

var allNumbersExceptFirstTwo = numbers.Skip(2);
Console.WriteLine(string.Join(",", allNumbersExceptFirstTwo.ToArray()));

//3,4,5

取る

このメソッドは、最初のn要素を列挙型から取ります。 

var numbers = new[] {1,2,3,4,5};

var threeFirstNumbers = numbers.Take(3);
Console.WriteLine(string.Join(",", threeFirstNumbers.ToArray()));

//1,2,3

SequenceEqual

var numbers = new[] {1,2,3,4,5};
var sameNumbers = new[] {1,2,3,4,5};
var sameNumbersInDifferentOrder = new[] {5,1,4,2,3};

var equalIfSameOrder = numbers.SequenceEqual(sameNumbers);
Console.WriteLine(equalIfSameOrder); //True

var equalIfDifferentOrder = numbers.SequenceEqual(sameNumbersInDifferentOrder);
Console.WriteLine(equalIfDifferentOrder); //False

逆

var numbers = new[] {1,2,3,4,5};
var reversed = numbers.Reverse();

Console.WriteLine(string.Join(",", reversed.ToArray()));

//5,4,3,2,1

OfType

var mixed = new object[] {1,"Foo",2,"Bar",3,"Fizz",4,"Buzz"};
var numbers = mixed.OfType<int>();

Console.WriteLine(string.Join(",", numbers.ToArray()));

//1,2,3,4

最大

var numbers = new[] {1,2,3,4};

var maxNumber = numbers.Max();
Console.WriteLine(maxNumber); //4

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var maxPopulation = cities.Max(c => c.Population);
Console.WriteLine(maxPopulation); //4000

分

var numbers = new[] {1,2,3,4};

var minNumber = numbers.Min();
Console.WriteLine(minNumber); //1

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var minPopulation = cities.Min(c => c.Population);
Console.WriteLine(minPopulation); //1000

平均

var numbers = new[] {1,2,3,4};

var averageNumber = numbers.Average();
Console.WriteLine(averageNumber); 
// 2,5

このメソッドは、列挙可能な数値の平均を計算します。 

var cities = new[] {
    new {Population = 1000},
    new {Population = 2000},
    new {Population = 4000}
};

var averagePopulation = cities.Average(c => c.Population);
Console.WriteLine(averagePopulation);
// 2333,33

このメソッドは、委譲された関数を使用して列挙可能な値の平均を計算します。

ジップ

.NET 4.0 
var tens = new[] {10,20,30,40,50};
var units = new[] {1,2,3,4,5};

var sums = tens.Zip(units, (first, second) => first + second);

Console.WriteLine(string.Join(",", sums));

//11,22,33,44,55

独特な

var numbers = new[] {1, 1, 2, 2, 3, 3, 4, 4, 5, 5};
var distinctNumbers = numbers.Distinct();

Console.WriteLine(string.Join(",", distinctNumbers));

//1,2,3,4,5

GroupBy

var persons = new[] {
    new { Name="Fizz", Job="Developer"},
    new { Name="Buzz", Job="Developer"},
    new { Name="Foo", Job="Astronaut"},
    new { Name="Bar", Job="Astronaut"},
};

var groupedByJob = persons.GroupBy(p => p.Job);

foreach(var theGroup in groupedByJob)
{
    Console.WriteLine(
        "{0} are {1}s", 
        string.Join(",", theGroup.Select(g => g.Name).ToArray()),
        theGroup.Key);
}

//Fizz,Buzz are Developers
//Foo,Bar are Astronauts

国別の請求書をグループ化し、レコード数、合計支払額、平均支払額で新しいオブジェクトを生成する

var a = db.Invoices.GroupBy(i => i.Country)
          .Select(g => new { Country = g.Key,
                             Count = g.Count(),
                             Total = g.Sum(i => i.Paid),
                             Average = g.Average(i => i.Paid) });

集計だけを望むならば、グループはありません

var a = db.Invoices.GroupBy(i => 1)
          .Select(g => new { Count = g.Count(),
                             Total = g.Sum(i => i.Paid),
                             Average = g.Average(i => i.Paid) });

何回かカウントが必要な場合

var a = db.Invoices.GroupBy(g => 1)
          .Select(g => new { High = g.Count(i => i.Paid >= 1000),
                             Low = g.Count(i => i.Paid < 1000),
                             Sum = g.Sum(i => i.Paid) });

ToDictionary

提供されたkeySelector関数を使用してキーを決定するIEnumerableソースから新しい辞書を返します。 keySelectorがインジェクション型でない場合（ソースコレクションの各メンバに一意の値を返します）、 ArgumentExceptionスローします。格納する値とキーを指定できるオーバーロードがあります。 

var persons = new[] {
    new { Name="Fizz", Id=1},
    new { Name="Buzz", Id=2},
    new { Name="Foo", Id=3},
    new { Name="Bar", Id=4},
};

ちょうどキーセレクター関数を指定すると、作成されDictionary<TKey,TVal>とTKey鍵セレクタ、の戻り型TVal元のオブジェクト・タイプ、および格納された値と元のオブジェクト。 

var personsById = persons.ToDictionary(p => p.Id);
// personsById is a Dictionary<int,object>

Console.WriteLine(personsById[1].Name); //Fizz
Console.WriteLine(personsById[2].Name); //Buzz

値セレクタ関数を指定すると、 Dictionary<TKey,TVal>も作成されますが、 TKeyはキーセレクタの戻り値の型ですが、 TValは値セレクタ関数の戻り値の型と戻り値を格納値として返します。 

var namesById = persons.ToDictionary(p => p.Id, p => p.Name);
//namesById is a Dictionary<int,string>

Console.WriteLine(namesById[3]); //Foo
Console.WriteLine(namesById[4]); //Bar

上記のように、キーセレクタによって返されるキーは一意でなければなりません。以下は例外をスローします。 

var persons = new[] {
    new { Name="Fizz", Id=1},
    new { Name="Buzz", Id=2},
    new { Name="Foo", Id=3},
    new { Name="Bar", Id=4},
    new { Name="Oops", Id=4}
};

var willThrowException = persons.ToDictionary(p => p.Id)

ソースコレクションに対して一意のキーを指定できない場合は、代わりにToLookupを使用することを検討してください。表面上、ToLookupはToDictionaryと同様に動作しますが、結果のLookupでは各キーは一致するキーを持つ値のコレクションとペアになります。

連合

var numbers1to5 = new[] {1,2,3,4,5};
var numbers4to8 = new[] {4,5,6,7,8};

var numbers1to8 = numbers1to5.Union(numbers4to8);

Console.WriteLine(string.Join(",", numbers1to8));

//1,2,3,4,5,6,7,8

重複が結果から削除されることに注意してください。これが望ましくない場合は、代わりにConcat使用してください。

ToArray

var numbers = new[] {1,2,3,4,5,6,7,8,9,10};
var someNumbers = numbers.Where(n => n < 6);

Console.WriteLine(someNumbers.GetType().Name);
//WhereArrayIterator`1

var someNumbersArray = someNumbers.ToArray();

Console.WriteLine(someNumbersArray.GetType().Name);
//Int32[]

ToList

var numbers = new[] {1,2,3,4,5,6,7,8,9,10};
var someNumbers = numbers.Where(n => n < 6);

Console.WriteLine(someNumbers.GetType().Name);
//WhereArrayIterator`1

var someNumbersList = someNumbers.ToList();

Console.WriteLine(
    someNumbersList.GetType().Name + " - " +
    someNumbersList.GetType().GetGenericArguments()[0].Name);
//List`1 - Int32

カウント

IEnumerable<int> numbers = new[] {1,2,3,4,5,6,7,8,9,10};

var numbersCount = numbers.Count();
Console.WriteLine(numbersCount); //10

var evenNumbersCount = numbers.Count(n => (n & 1) == 0);
Console.WriteLine(evenNumbersCount); //5

ElementAt

var names = new[] {"Foo","Bar","Fizz","Buzz"};

var thirdName = names.ElementAt(2);
Console.WriteLine(thirdName); //Fizz

//The following throws ArgumentOutOfRangeException

var minusOnethName = names.ElementAt(-1);
var fifthName = names.ElementAt(4);

ElementAtOrDefault

var names = new[] {"Foo","Bar","Fizz","Buzz"};

var thirdName = names.ElementAtOrDefault(2);
Console.WriteLine(thirdName); //Fizz

var minusOnethName = names.ElementAtOrDefault(-1);
Console.WriteLine(minusOnethName); //null

var fifthName = names.ElementAtOrDefault(4);
Console.WriteLine(fifthName); //null

SkipWhile

var numbers = new[] {2,4,6,8,1,3,5,7};

var oddNumbers = numbers.SkipWhile(n => (n & 1) == 0);

Console.WriteLine(string.Join(",", oddNumbers.ToArray()));

//1,3,5,7

TakeWhile

var numbers = new[] {2,4,6,1,3,5,7,8};

var evenNumbers = numbers.TakeWhile(n => (n & 1) == 0);

Console.WriteLine(string.Join(",", evenNumbers.ToArray()));

//2,4,6

DefaultIfEmpty

var numbers = new[] {2,4,6,8,1,3,5,7};

var numbersOrDefault = numbers.DefaultIfEmpty();
Console.WriteLine(numbers.SequenceEqual(numbersOrDefault)); //True

var noNumbers = new int[0];

var noNumbersOrDefault = noNumbers.DefaultIfEmpty();
Console.WriteLine(noNumbersOrDefault.Count()); //1
Console.WriteLine(noNumbersOrDefault.Single()); //0

var noNumbersOrExplicitDefault = noNumbers.DefaultIfEmpty(34);
Console.WriteLine(noNumbersOrExplicitDefault.Count()); //1
Console.WriteLine(noNumbersOrExplicitDefault.Single()); //34

集約（折りたたみ）

各ステップで新しいオブジェクトを生成する： 

var elements = new[] {1,2,3,4,5};

var commaSeparatedElements = elements.Aggregate(
    seed: "",
    func: (aggregate, element) => $"{aggregate}{element},");
    
Console.WriteLine(commaSeparatedElements);  //1,2,3,4,5,

すべてのステップで同じオブジェクトを使用する： 

var commaSeparatedElements2 = elements.Aggregate(
    seed: new StringBuilder(),
    func: (seed, element) => seed.Append($"{element},"));
    
Console.WriteLine(commaSeparatedElements2.ToString());  //1,2,3,4,5,

結果セレクタの使用： 

var commaSeparatedElements3 = elements.Aggregate(
    seed: new StringBuilder(),
    func: (seed, element) => seed.Append($"{element},"),
    resultSelector: (seed) => seed.ToString());
Console.WriteLine(commaSeparatedElements3);  //1,2,3,4,5,

シードが省略された場合、最初の要素はシードになります。 

var seedAndElements = elements.Select(n=>n.ToString());
var commaSeparatedElements4 = seedAndElements.Aggregate(
    func: (aggregate, element) => $"{aggregate}{element},");

Console.WriteLine(commaSeparatedElements4);  //12,3,4,5,

見上げる

var persons = new[] {
    new { Name="Fizz", Job="Developer"},
    new { Name="Buzz", Job="Developer"},
    new { Name="Foo", Job="Astronaut"},
    new { Name="Bar", Job="Astronaut"},
};

var groupedByJob = persons.ToLookup(p => p.Job);

foreach(var theGroup in groupedByJob)
{
    Console.WriteLine(
        "{0} are {1}s", 
        string.Join(",", theGroup.Select(g => g.Name).ToArray()),
        theGroup.Key);
}

//Fizz,Buzz are Developers
//Foo,Bar are Astronauts

参加する

class Developer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Project
{
    public int DeveloperId { get; set; }
    public string Name { get; set; }
}

var developers = new[] {
    new Developer {
        Id = 1,
        Name = "Foobuzz"
    },
    new Developer {
        Id = 2,
        Name = "Barfizz"
    }
};

var projects = new[] {
    new Project {
        DeveloperId = 1,
        Name = "Hello World 3D"
    },
    new Project {
        DeveloperId = 1,
        Name = "Super Fizzbuzz Maker"
    },
    new Project {
        DeveloperId = 2,
        Name = "Citizen Kane - The action game"
    },
    new Project {
        DeveloperId = 2,
        Name = "Pro Pong 2016"
    }
};

var denormalized = developers.Join(
    inner: projects,
    outerKeySelector: dev => dev.Id,
    innerKeySelector: proj => proj.DeveloperId,
    resultSelector: 
        (dev, proj) => new {
            ProjectName = proj.Name,
            DeveloperName = dev.Name});
    
foreach(var item in denormalized)
{
    Console.WriteLine("{0} by {1}", item.ProjectName, item.DeveloperName);
}

//Hello World 3D by Foobuzz
//Super Fizzbuzz Maker by Foobuzz
//Citizen Kane - The action game by Barfizz
//Pro Pong 2016 by Barfizz

GroupJoin

class Developer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Project
{
    public int DeveloperId { get; set; }
    public string Name { get; set; }
}

var developers = new[] {
    new Developer {
        Id = 1,
        Name = "Foobuzz"
    },
    new Developer {
        Id = 2,
        Name = "Barfizz"
    }
};

var projects = new[] {
    new Project {
        DeveloperId = 1,
        Name = "Hello World 3D"
    },
    new Project {
        DeveloperId = 1,
        Name = "Super Fizzbuzz Maker"
    },
    new Project {
        DeveloperId = 2,
        Name = "Citizen Kane - The action game"
    },
    new Project {
        DeveloperId = 2,
        Name = "Pro Pong 2016"
    }
};

var grouped = developers.GroupJoin(
    inner: projects,
    outerKeySelector: dev => dev.Id,
    innerKeySelector: proj => proj.DeveloperId,
    resultSelector: 
        (dev, projs) => new {
            DeveloperName = dev.Name, 
            ProjectNames = projs.Select(p => p.Name).ToArray()});
    
foreach(var item in grouped)
{
    Console.WriteLine(
        "{0}'s projects: {1}", 
        item.DeveloperName,
        string.Join(", ", item.ProjectNames));
}

//Foobuzz's projects: Hello World 3D, Super Fizzbuzz Maker
//Barfizz's projects: Citizen Kane - The action game, Pro Pong 2016

キャスト

Castは、 IEnumerable拡張メソッドであり、 IEnumerable<T>ではなく、 Enumerableの他のメソッドとは異なりEnumerable 。したがって、前者のインスタンスを後のインスタンスに変換するために使用できます。

これは、 ArrayListはIEnumerable<T>実装していないため、コンパイルされません。 

var numbers = new ArrayList() {1,2,3,4,5};
Console.WriteLine(numbers.First());

期待どおりに動作します。 

var numbers = new ArrayList() {1,2,3,4,5};
Console.WriteLine(numbers.Cast<int>().First()); //1

Castは変換キャストを実行しません 。次のコンパイルは実行時にInvalidCastExceptionをスローします。 

var numbers = new int[] {1,2,3,4,5};
decimal[] numbersAsDecimal = numbers.Cast<decimal>().ToArray();

コレクションへの変換キャストを実行する適切な方法は、次のとおりです。 

var numbers= new int[] {1,2,3,4,5};
decimal[] numbersAsDecimal = numbers.Select(n => (decimal)n).ToArray();

空の

intの空のIEnumerableを作成するには： 

IEnumerable<int> emptyList = Enumerable.Empty<int>();

この空のIEnumerableは、各タイプTに対してキャッシュされるため、次のようになります。 

Enumerable.Empty<decimal>() == Enumerable.Empty<decimal>(); // This is True
Enumerable.Empty<int>() == Enumerable.Empty<decimal>();     // This is False

次に、

ThenByはOrderBy節の後にのみ使用でき、複数の条件を使用して注文することができます

var persons = new[] 
{
    new {Id = 1, Name = "Foo", Order = 1},
    new {Id = 1, Name = "FooTwo", Order = 2},
    new {Id = 2, Name = "Bar", Order = 2},
    new {Id = 2, Name = "BarTwo", Order = 1},
    new {Id = 3, Name = "Fizz", Order = 2},
    new {Id = 3, Name = "FizzTwo", Order = 1},  
};

var personsSortedByName = persons.OrderBy(p => p.Id).ThenBy(p => p.Order);

Console.WriteLine(string.Join(",", personsSortedByName.Select(p => p.Name)));
//This will display : 
//Foo,FooTwo,BarTwo,Bar,FizzTwo,Fizz

範囲

Rangeの2つのパラメータは、 最初の数と生成する要素の数です（最後の数ではありません）。 

// prints 1,2,3,4,5,6,7,8,9,10
Console.WriteLine(string.Join(",", Enumerable.Range(1, 10)));

// prints 10,11,12,13,14
Console.WriteLine(string.Join(",", Enumerable.Range(10, 5)));

左外部結合

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

class Pet
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}

public static void Main(string[] args)
{
    var magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
    var terry = new Person { FirstName = "Terry", LastName = "Adams" };

    var barley = new Pet { Name = "Barley", Owner = terry };

    var people = new[] { magnus, terry };
    var pets = new[] { barley };

    var query =
        from person in people
        join pet in pets on person equals pet.Owner into gj
        from subpet in gj.DefaultIfEmpty()
        select new
        {
            person.FirstName,
            PetName = subpet?.Name ?? "-" // Use - if he has no pet
        };

    foreach (var p in query)
        Console.WriteLine($"{p.FirstName}: {p.PetName}");
}

繰り返す

Enumerable.Repeatは、繰り返し値のシーケンスを生成します。この例では、「Hello」を4回生成します。 

var repeats = Enumerable.Repeat("Hello", 4);
   
foreach (var item in repeats)
{
    Console.WriteLine(item);
}

/* output:
    Hello
    Hello
    Hello
    Hello
*/


Modified text is an extract of the original Stack Overflow Documentation
ライセンスを受けた CC BY-SA 3.0
所属していない Stack Overflow