Enumerableクラス

このクラスのメソッドはほぼ拡張メソッドのため、使用するにはusing System.Linqで名前空間を指定するか、第1引数のsourceへコレクションを渡します。

遅延実行 (deferred execution) で実装されているメソッドから返されるクエリは、GetEnumerator()またはforeachで列挙されるまで実行されません。

型の変換

Cast()

IEnumerableの要素を、指定の型へキャストできます。

このメソッドは遅延実行で実装されています。

public static System.Collections.Generic.IEnumerable<TResult> Cast<TResult> (
    this System.Collections.IEnumerable source
    );

Enumerable.Cast<TResult>(IEnumerable) Method (System.Linq) | Microsoft Learn

このメソッドで変換することで、IEnumerableを実装するがIEnumerable<T>を実装しない型に、このクラスの他のメソッドを適用できます。.net - Does LINQ work with IEnumerable? - Stack Overflow

ArrayList source = new ArrayList { 1, 2, 3 };
IEnumerable<int> query = source.Cast<int>();

IEnumerable<TResult>にキャスト可能ならばsourceがそのまま返され、不可能ならば要素が1つずつ(TResult)でキャストされます。Cast - Enumerable.cs

TResultにキャストできない要素があるとInvalidCastExceptionが投げられるため、キャスト可能な要素だけを対象とするにはOfType()を用います。Remarks - Enumerable.Cast<TResult>(IEnumerable) Method (System.Linq) | Microsoft Learn

ToArray()

sourceの型の配列を作成できます。

public static TSource[] ToArray<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source
    );

Enumerable.ToArray<TSource>(IEnumerable<TSource>) メソッド (System.Linq) | Microsoft Learn

sourceがICollection<T>を実装するならばそのCopyTo()で、さもなくばArray.Copy()でコピーされた配列が返されます。

public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source) {
    if (source == null) throw Error.ArgumentNull("source");
    return new Buffer<TSource>(source).ToArray();
}

ToArray - Enumerable.cs

ToList()

List<T>を作成できます。

public static System.Collections.Generic.List<TSource> ToList<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source
    );

Enumerable.ToList<TSource>(IEnumerable<TSource>) メソッド (System.Linq) | Microsoft Learn

内部ではListのコンストラクタList<T>(IEnumerable<T>)を呼ぶことにより、List<T>が作成されています。

public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source) {
    if (source == null) throw Error.ArgumentNull("source");
    return new List<TSource>(source);
}

ToList - Enumerable.cs

int[] source = { 10, 20, 30 };
List<int> result = source.ToList();

ToHashSet()

HashSet<T>を作成できます。

public static System.Collections.Generic.HashSet<TSource> ToHashSet<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source
    );

ToHashSet<TSource>(IEnumerable<TSource> - Enumerable.ToHashSet メソッド (System.Linq) | Microsoft Learn

ToDictionary()

Dictionary<TKey,TValue>を作成できます。

public static System.Collections.Generic.Dictionary<TKey,TElement> ToDictionary<TSource,TKey,TElement> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,TKey> keySelector,
    Func<TSource,TElement> elementSelector
    );

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) - Enumerable.ToDictionary メソッド (System.Linq) | Microsoft Learn

内部ではkeySelectorとelementSelectorで作成したkeyとvalueで、Dictionary<TKey,TValue>.Add()によって要素がひとつずつ追加されます。ToDictionary - Enumerable.cs

結果のフィルタ

Where()

述語 (predicate) で、シーケンスの要素をフィルター処理できます。つまり、条件を満たす要素をすべて取得できます。

このメソッドは遅延実行で実装されています。

public static System.Collections.Generic.IEnumerable<TSource> Where<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,bool> predicate
    );

Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) - Enumerable.Where メソッド (System.Linq) | Microsoft Learn

int[] source = { 4, 5, 6, 1, 2, 3 };
IEnumerable<int> query = source.Where(x => x % 2 == 0);
query.ToArray(); // 4, 6, 2

OfType()

型で、要素をフィルター処理できます。

このメソッドは遅延実行で実装されています。

public static System.Collections.Generic.IEnumerable<TResult> OfType<TResult> (
    this System.Collections.IEnumerable source
    );

Enumerable.OfType<TResult>(IEnumerable) メソッド (System.Linq) | Microsoft Learn

Single()

シーケンス (sequence / 順番) から、唯一の要素を取得できます。

public static TSource Single<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source
    );

Single<TSource>(IEnumerable<TSource>) - Enumerable.Single メソッド (System.Linq) | Microsoft Learn

要素が1つだけではない場合は、InvalidOperationExceptionが発生します。

Distinct()

シーケンスから独特な要素 (distinct elements)、つまり重複しない要素を取得できます。

このメソッドは遅延実行で実装されています。

public static System.Collections.Generic.IEnumerable<TSource> Distinct<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source
    );

Distinct<TSource>(IEnumerable<TSource>) - Enumerable.Distinct メソッド (System.Linq) | Microsoft Learn

int[] source = { 3, 2, 1, 2, 1, 1 };
IEnumerable<int> query = source.Distinct();
query.ToArray(); // 3, 2, 1

結果の型と形状

Select()

シーケンスの各要素を、新しいフォーム (form) に射影 (project) できます。

このメソッドは遅延実行で実装されています。

public static IEnumerable<TResult> Select<TSource, TResult>(
    this IEnumerable<TSource> source,
    Func<TSource, TResult> selector
    )

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) - Enumerable.Select メソッド (System.Linq) | Microsoft Learn

sourceの各要素がselectorで処理された結果が返されます。

int[] source = { 1, 2, 3 };
IEnumerable<int> query = source.Select(x => x * x);
query.ToArray(); // 1, 4, 9

Point[] source = { new Point(1, 2), new Point(3, 4) };
IEnumerable<int> query = source.Select(point => point.X);
query.ToArray(); // 1, 3

SelectMany()

シーケンスの各要素を新しいフォームに射影し、結果のシーケンスを1つのシーケンスにまとめられます。

public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,System.Collections.Generic.IEnumerable<TResult>> selector
    );

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) - Enumerable.SelectMany メソッド (System.Linq) | Microsoft Learn

string[] source = { "A", "B,C,D", "E,F" };
IEnumerable<string> query = source.SelectMany(x => x.Split(','));
query.ToArray(); // "A", "B", "C", "D", "E", "F"

グループ化

GroupBy()

シーケンスの要素を、グループ化できます。

このメソッドは遅延実行で実装されています。

public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,TKey> keySelector
    );

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) - Enumerable.GroupBy メソッド (System.Linq) | Microsoft Learn

int[] source = { 3, 1, 2, 2, 3, 3, 3 };
IEnumerable<IGrouping<int, int>> query = source.GroupBy(x => x);

Dictionary<int, int> dic = query.ToDictionary(s => s.Key, s => s.Count());
// {[3, 4]}
// {[1, 1]}
// {[2, 2]}

比較子を指定しないオーバーロードでは、EqualityComparer<TKey>.Defaultで得られる既定の比較子によってTKeyが比較されます。 GroupBy - Enumerable.cs Lookup - Enumerable.cs

たとえば次のように定義されたシーケンスがあるとき、

class MyClass
{
    public int num;
    public string str;
}

List<MyClass> lists = new List<MyClass>
{
    new MyClass() { num=1, str="a" },
    new MyClass() { num=2, str="a" },
    new MyClass() { num=3, str="b" },
    new MyClass() { num=4, str="c" },
    new MyClass() { num=5, str="c" },
};

グループ化された要素は、

IEnumerable<IGrouping<string, MyClass>> query = lists.GroupBy(myClass => myClass.str);
int count = query.Count(); // 3

foreach (IGrouping<string, MyClass> group in query) // グループを1つずつ列挙する
{
    string key = group.Key; // "a", "b", "c"

    foreach (MyClass item in group) // グループ内の項目を1つずつ列挙する
    {
        int num = item.num; // 1, 2, 3, 4, 5
    }
}

のように列挙することで取得できます。グループクエリの結果を列挙する - group 句 - C# リファレンス | Microsoft Learn

グループ化の方法の指定

10～19、20～29のようにグループ化する値に範囲を持たせるならば、キーセレクタの関数を指定します。

public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,TKey> keySelector
    );

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) - Enumerable.GroupBy メソッド (System.Linq) | Microsoft Learn

int[] source = { 5, 10, 15, 20, 25 };
IEnumerable<IGrouping<int, int>> query = source.GroupBy(x => x / 10);

Dictionary<int, string> dic = query.ToDictionary(s => s.Key, s => String.Join(",", s));
// {[0, 5]}
// {[1, 10,15]}
// {[2, 20,25]}

比較方法の指定

要素の比較方法を指定するには、IEqualityComparer<TKey>を引数にとるオーバーロードを指定します。

public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,TKey> keySelector,
    System.Collections.Generic.IEqualityComparer<TKey> comparer
    );

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) - Enumerable.GroupBy メソッド (System.Linq) | Microsoft Learn

IEqualityComparer<TKey>を継承したクラスで、比較方法を指定します。

Equals()は、2つのオブジェクトに対してGetHashCode()が同じ値を返すときのみ呼び出されます。

class MyComparer : IEqualityComparer<string>
{
    public bool Equals(string x, string y)
    {
        return x[0] == y[0] && x.Length == y.Length;
    }

    public int GetHashCode(string obj)
    {
        string str = $"{obj[0]}{obj.Length}";
        return str.GetHashCode();
    }
}

string[] source = { "B1", "A1", "A2", "B2", "B30" };

MyComparer comparer = new MyComparer();
IEnumerable<IGrouping<string, string>> query = source.GroupBy(word => word, comparer);

または、複合キーを用います。

string[] source = { "B1", "A1", "A2", "B2", "B30" };
var query = source.GroupBy(word => new { c = word[0], length = word.Length });

並べ替え

Reverse()

シーケンスの要素の順を、反転させられます。

このメソッドは遅延実行で実装されています。

public static System.Collections.Generic.IEnumerable<TSource> Reverse<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source
    );

Enumerable.Reverse<TSource>(IEnumerable<TSource>) メソッド (System.Linq) | Microsoft Learn

内部的には新しいコレクションにコピーされ、その要素をインデクサで逆順に取得した値が返されます。Reverse - Enumerable.cs

static IEnumerable<TSource> ReverseIterator<TSource>(IEnumerable<TSource> source) {
    Buffer<TSource> buffer = new Buffer<TSource>(source);
    for (int i = buffer.count - 1; i >= 0; i--) yield return buffer.items[i];
}

OrderBy()

キー (key) で、シーケンスの要素を昇順 (ascending order) に並べ替えられます。

このメソッドは遅延実行で実装されています。

public static System.Linq.IOrderedEnumerable<TSource> OrderBy<TSource,TKey> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,TKey> keySelector
    );

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) - Enumerable.OrderBy メソッド (System.Linq) | Microsoft Learn

比較子を指定しないオーバーロードでは、Comparer<T>.Defaultで得られる既定の比較子によってTKeyが比較されます。そしてその既定の比較子は、Comparer<T>.CreateComparer()で作成されたものです。

int[] source = { 4, 5, 6, 1, 2 };
IOrderedEnumerable<int> query = source.OrderBy(x => x);
query.ToArray(); // 1, 2, 4, 5, 6

シーケンスの要素がIComparableを実装せず比較可能ではないと、「少なくとも 1 つのオブジェクトで IComparable を実装しなければなりません。」としてArgumentExceptionが投げられます。

object[] source = { new object(), new object() };
IOrderedEnumerable<object> query = source.OrderBy(x => x);
query.ToArray(); // ArgumentException

比較方法を変更するならば、第3引数でそれを指定します。

public static System.Linq.IOrderedEnumerable<TSource> OrderBy<TSource,TKey> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,TKey> keySelector,
    System.Collections.Generic.IComparer<TKey> comparer
    );

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) - Enumerable.OrderBy メソッド (System.Linq) | Microsoft Learn

さらに後続する要素を並べ替えるならば、ThenBy()を呼びます。

OrderByDescending()

降順 (descending order) に並べ替えられます。

Enumerable.OrderByDescending Method (System.Linq) | Microsoft Learn

ThenBy()

キーで、シーケンスの要素の後の順序を、昇順に並べ替えられます。

public static System.Linq.IOrderedEnumerable<TSource> ThenBy<TSource,TKey> (
    this System.Linq.IOrderedEnumerable<TSource> source,
    Func<TSource,TKey> keySelector
    );

ThenBy<TSource,TKey>(IOrderedEnumerable<TSource>, Func<TSource,TKey>) - Enumerable.ThenBy Method (System.Linq) | Microsoft Learn

string[] source = { "b", "bb", "aa", "a" };
IOrderedEnumerable<string> query1 = source.OrderBy(x => x.Length);
IOrderedEnumerable<string> query2 = source.OrderBy(x => x.Length).ThenBy(x => x);

query1.ToArray(); // "b", "a", "bb", "aa"
query2.ToArray(); // "a", "b", "aa", "bb" 


IOrderedEnumerable<string> query3 = query1.OrderBy(x => x); // OrderBy()の結果にOrderBy()を適用
IOrderedEnumerable<string> query4 = query1.ThenBy(x => x);

query3.ToArray(); // "a", "aa", "b", "bb" query1の結果が反映されない
query4.ToArray(); // "a", "b", "aa", "bb"

ThenByDescending()

降順に並べ替えられます。

結合

Join()

キーで、2つのシーケンスの要素を関連付けられます。キーの比較には、既定の等値演算子が用いられます。

このメソッドは遅延実行で実装されています。

public static System.Collections.Generic.IEnumerable<TResult> Join<TOuter,TInner,TKey,TResult> (
    this System.Collections.Generic.IEnumerable<TOuter> outer,
    System.Collections.Generic.IEnumerable<TInner> inner,
    Func<TOuter,TKey> outerKeySelector,
    Func<TInner,TKey> innerKeySelector,
    Func<TOuter,TInner,TResult> resultSelector
    );

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) - Enumerable.Join メソッド (System.Linq) | Microsoft Learn

Concat()

2つのシーケンスを連結できます。

public static System.Collections.Generic.IEnumerable<TSource> Concat<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> first,
    System.Collections.Generic.IEnumerable<TSource> second
    );

Enumerable.Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) メソッド (System.Linq) | Microsoft Learn

指定範囲の要素の取得

First()

シーケンスの最初の要素を得られます。

public static TSource First<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source
    );

First<TSource>(IEnumerable<TSource>) - Enumerable.First メソッド (System.Linq) | Microsoft Learn

sourceがIList<T>を実装しているならばそのItem[0]から読み込むのに等しく、さもなくばGetEnumerator()を介して得られるIEnumerator<T>のCurrentと等しいです。First - Enumerable.cs

よってIList<T>を実装しているならば別スレッドでコレクションが変更されても影響されませんが、そうでなければそのような状況ではInvalidOperationExceptionが投げられます。

int[] source = { 1, 2, 3 };
int r = source.First(); // 1

要素数が0だと、「シーケンスに要素が含まれていません (Sequence contains no elements)」としてInvalidOperationExceptionが投げられます。このようなときFirstOrDefault()ならば、既定値が返されます。

int[] source = { };
int r1 = source.First();          // InvalidOperationException
int r2 = source.FirstOrDefault(); // 0

条件を満たす要素の取得

指定の条件を満たす、シーケンスの最初の要素を得られます。

public static TSource First<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,bool> predicate
    );

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) - Enumerable.First メソッド (System.Linq) | Microsoft Learn

条件を満たす要素がないと、InvalidOperationExceptionが投げられます。このようなときFirstOrDefault()ならば、既定値が返されます。

string[] source = { "A1", "B2", "C3" };

string r1 = source.First(x => x[0] == 'B'); // "B2"
string r2 = source.First(x => x[0] == 'D'); // InvalidOperationException

string r3 = source.FirstOrDefault(x => x[0] == 'D'); // null

最初の要素だけではなく、すべての要素を取得したいならばWhere()を用います。

FirstOrDefault()

public static TSource FirstOrDefault<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,bool> predicate
    );

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) - Enumerable.FirstOrDefault メソッド (System.Linq) | Microsoft Learn

Last()

シーケンスの最後の要素を得られます。

public static TSource Last<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source
    );

Last<TSource>(IEnumerable<TSource>) - Enumerable.Last メソッド (System.Linq) | Microsoft Learn

sourceがIList<T>を実装しているならばそのItem[Count-1]から読み込むのに等しく、さもなくばIEnumerator<T>を末尾までループさせた結果が返されます。Last - Enumerable.cs

Take()

シーケンスの先頭から、指定数の連続する要素を得られます。

public static System.Collections.Generic.IEnumerable<TSource> Take<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    int count
    );

Enumerable.Take メソッド (System.Linq) | Microsoft Learn

int[] source = { 1, 2, 3, 4, 5 };
IEnumerable<int> query = source.Take(3);
query.ToArray(); // 1, 2, 3

Skip()

シーケンスの先頭から、指定数の連続する要素を迂回して、残りの要素を得られます。

public static System.Collections.Generic.IEnumerable<TSource> Skip<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    int count
    );

Enumerable.Skip<TSource>(IEnumerable<TSource>, Int32) メソッド (System.Linq) | Microsoft Learn

int[] source = { 1, 2, 3, 4, 5 };
IEnumerable<int> query = source.Skip(3);
query.ToArray(); // 4, 5

Take()とSkip()は機能的に補完しており、これらで同数の要素を得て連結すると、元のシーケンスと同じとなります。

IEnumerable<int> query2 = source.Take(3).Concat(source.Skip(3));
query2.ToArray(); // 1, 2, 3, 4, 5

要素の数

Count()

シーケンスの要素数を得られます。

要素の存在を確認したいだけならば、代わりにAny()を用います。

public static int Count<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source
    );

Count<TSource>(IEnumerable<TSource>) - Enumerable.Count メソッド (System.Linq) | Microsoft Learn

sourceがICollection<T>かICollectionを実装しているならばそのCountプロパティの値が返されますが、さもなくばMoveNext()でシーケンスの末尾までくり返した数が返されます。Count - Enumerable.cs

int[] source1 = { 1, 2, 3 };
int[] source2 = { };

int count1 = source1.Count(); // 3
int count2 = source2.Count(); // 0

条件を満たす要素の数を取得

public static int Count<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,bool> predicate
    );

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) - Enumerable.Count メソッド (System.Linq) | Microsoft Learn

Any()

シーケンスに要素が含まれているか確認できます。

public static bool Any<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source
    );

Any<TSource>(IEnumerable<TSource>) - Enumerable.Any メソッド (System.Linq) | Microsoft Learn

要素が含まれていれば、trueが返されます。

int[] source1 = { 1, 2, 3 };
int[] source2 = { };

bool r1 = source1.Any(); // true
bool r2 = source2.Any(); // false

内部ではMoveNext()で列挙子を進めてみることで判別しています。

public static bool Any<TSource>(this IEnumerable<TSource> source) {
    if (source == null) throw Error.ArgumentNull("source");
    using (IEnumerator<TSource> e = source.GetEnumerator()) {
        if (e.MoveNext()) return true;
    }
    return false;
}

Any - Enumerable.cs

条件を満たす要素が含まれているか確認

シーケンスに、条件を満たす要素が含まれているか確認できます。

public static bool Any<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,bool> predicate
    );

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) - Enumerable.Any メソッド (System.Linq) | Microsoft Learn

内部ではpredicateにsourceの要素を順に与え、trueを返す要素があるならばtrueが返されるようになっています。Any - Enumerable.cs

int[] source = { 1, 2, 3 };
bool r1 = source.Any(x => 5 < x); // false
bool r2 = source.Any(x => 5 > x); // true

条件を満たす要素の有無ではなく、すべての要素が条件を満たすことを確認したいならばAll()を用います。また対象によってはArray.Exists<T>()、List<T>.Exists()でも確認できます。

All()

シーケンスのすべての要素が、条件を満たしているか確認できます。

public static bool All<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,bool> predicate
    );

Enumerable.All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) メソッド (System.Linq) | Microsoft Learn

要素の比較

SequenceEqual()

2つのシーケンスが等しいか確認できます。

public static bool SequenceEqual<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> first,
    System.Collections.Generic.IEnumerable<TSource> second
    );

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) - Enumerable.SequenceEqual メソッド (System.Linq) | Microsoft Learn

int[] x = { 1, 2, 3 };

int[] a1 = { 1, 2, 3 };
int[] a2 = { 1, 2, 10 };
int[] a3 = { 3, 2, 1 };
int[] a4 = { 1, 2, 3, 4 };

bool r1 = x.SequenceEqual(a1); // true
bool r2 = x.SequenceEqual(a2); // false
bool r3 = x.SequenceEqual(a3); // false
bool r4 = x.SequenceEqual(a4); // false

Contains()

指定の要素が、シーケンスに含まれているか確認できます。

public static bool Contains<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    TSource value
    );

Contains<TSource>(IEnumerable<TSource>, TSource) - Enumerable.Contains メソッド (System.Linq) | Microsoft Learn

sourceがICollection<T>を実装するならば、そのContains()が呼ばれます。さもなくばシーケンスの要素が、1つずつ既定の等値演算子で比較されます。Contains - Enumerable.cs

なおArray.IList.Contains()でも、要素が1つずつ比較されています。IList.Contains - array.cs

比較方法の指定

要素の比較方法を変更するには、それを指定します。

public static bool Contains<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    TSource value,
    System.Collections.Generic.IEqualityComparer<TSource> comparer
    );

集合演算

Union()

2つのシーケンスの和集合 (union) を生成、つまり要素が重複しないようにまとめられます。

このメソッドは遅延実行で実装されています。

public static System.Collections.Generic.IEnumerable<TSource> Union<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> first,
    System.Collections.Generic.IEnumerable<TSource> second
    );

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) - Enumerable.Union メソッド (System.Linq) | Microsoft Learn

int[] a1 = { 1, 2, 3 };
int[] a2 = { 2, 3, 4 };

IEnumerable<int> query = a1.Union(a2);
query.ToArray(); // 1, 2, 3, 4

Intersect()

2つのシーケンスの積集合 (intersection) を生成できます。

このメソッドは遅延実行で実装されています。

public static System.Collections.Generic.IEnumerable<TSource> Intersect<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> first,
    System.Collections.Generic.IEnumerable<TSource> second
    );

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) - Enumerable.Intersect メソッド (System.Linq) | Microsoft Learn

int[] a1 = { 1, 2, 3 };
int[] a2 = { 2, 3, 4 };

IEnumerable<int> query = a1.Intersect(a2);
query.ToArray(); // 2, 3

Except()

2つのシーケンスの差集合 (set difference) を生成できます。

このメソッドは遅延実行で実装されています。

int[] a1 = { 1, 2, 3 };
int[] a2 = { 2, 3, 4 };

IEnumerable<int> query = a1.Except(a2);
query.ToArray(); // 1

演算

Sum()

シーケンスの合計を得られます。

public static int Sum<TSource> (
    this System.Collections.Generic.IEnumerable<TSource> source,
    Func<TSource,int> selector
    );

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) - Enumerable.Sum メソッド (System.Linq) | Microsoft Learn

Dictionary<string, int> dictionary = new Dictionary<string, int>
{
    ["a"] = 1,
    ["b"] = 2,
    ["c"] = 3,
};

int sum = dictionary.Sum(dic => dic.Value); // 6

内部ではSelect()でselectorの新しいシーケンスを作成してから、Sum(IEnumerable<Int32>)で合計が求められています。Sum - Enumerable.cs

Max()

シーケンスの最大値を得られます。

public static int Max (this System.Collections.Generic.IEnumerable<int> source);

Max(IEnumerable<Int32>) - Enumerable.Max メソッド (System.Linq) | Microsoft Learn

public static TSource Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);

Max<TSource>(IEnumerable<TSource>) - Enumerable.Max メソッド (System.Linq) | Microsoft Learn

任意の型の最大値を得るには、その型がIComparableまたはIComparable<T>インターフェイスを実装し、比較可能となっている必要があります。

シーケンスの取得

Empty()

空のシーケンスを得られます。

public static System.Collections.Generic.IEnumerable<TResult> Empty<TResult> ();

Enumerable.Empty<TResult> メソッド (System.Linq) | Microsoft Learn

IEnumerable<int> query = Enumerable.Empty<int>();
query.Count(); // 0

Range()

指定範囲の整数のシーケンスを得られます。

このメソッドは遅延実行で実装されています。

public static System.Collections.Generic.IEnumerable<int> Range (
    int start, // 最初の値
    int count  // 生成する数
    );

IEnumerable<int> query = Enumerable.Range(2, 3);
query.ToArray(); // 2, 3, 4

Repeat()

指定値が指定数だけくり返されるシーケンスを得られます。

このメソッドは遅延実行で実装されています。

public static System.Collections.Generic.IEnumerable<TResult> Repeat<TResult> (
    TResult element,
    int count
    );

IEnumerable<int> query1 = Enumerable.Repeat(1, 3);
IEnumerable<string> query2 = Enumerable.Repeat("a", 3);

query1.ToArray(); // 1, 1, 1
query2.ToArray(); // "a", "a", "a"

参考

Enumerable クラス (System.Linq) | Microsoft Learn
Enumerable.cs (ソースコード)

Microsoft Learnから検索