LINQ

【C#】LINQのToList・ToArray・ToDictionaryで配列やリストをスマートに変換する方法

2025-05-20更新日: 2025-05-20

C#のLINQではToListやToArrayなどで簡単にコレクションを別形式へ変換でき、辞書化にはToDictionary、グループ化にはToLookupが役立ちます。

AsEnumerableでクエリをメモリに移し、Selectで匿名型を生成するなど柔軟な変換が可能です。

目次から探す

変換メソッド共通の基礎知識
ToListの詳細
ToArrayの詳細
ToDictionaryの詳細
補助的変換メソッド
パフォーマンス検証シナリオ
エラーハンドリングと落とし穴
実践ユースケース
コードメンテナンスのコツ
まとめ

変換メソッド共通の基礎知識

LINQにおけるシーケンスとは

LINQ(Language Integrated Query)で扱う「シーケンス」とは、IEnumerable<T>やIQueryable<T>のような、順序付けられたデータの集合を指します。

シーケンスは、配列やリスト、データベースのクエリ結果など、さまざまなデータソースを抽象化して扱うことができます。

シーケンスの特徴は、要素が順番に並んでいることと、要素の数が動的に変わる可能性があることです。

LINQのメソッドは、このシーケンスに対してフィルタリングや変換、集計などの操作を行います。

例えば、以下のコードは整数の配列をシーケンスとして扱い、偶数だけを抽出しています。

int[] numbers = { 1, 2, 3, 4, 5, 6 };
// numbersはIEnumerable<int>として扱われる
var evenNumbers = numbers.Where(n => n % 2 == 0);

ここでevenNumbersはIEnumerable<int>型のシーケンスであり、実際のデータはまだ評価されていません。

このように、LINQのシーケンスは「遅延実行」の性質を持つことが多いです。

即時実行と遅延実行の違い

LINQの操作には「遅延実行」と「即時実行」の2種類があります。

これらの違いを理解することは、変換メソッドを正しく使いこなすうえで非常に重要です。

遅延実行(Deferred Execution)

クエリの定義はすぐに行われますが、実際のデータの取得や処理は、結果が必要になったタイミングまで遅延されます。

WhereやSelectなどのメソッドは遅延実行の代表例です。

var query = numbers.Where(n => n > 3);
// この時点ではまだ処理は実行されていない
foreach (var num in query)
{
    Console.WriteLine(num);
}

foreachで列挙したときに初めて処理が実行されます。

即時実行(Immediate Execution)

クエリの定義と同時に処理が実行され、結果がすぐに返されます。

ToListやToArray、ToDictionaryなどの変換メソッドは即時実行を引き起こします。

var list = numbers.Where(n => n > 3).ToList();
// この時点で処理が実行され、結果がlistに格納される

遅延実行はパフォーマンス面で効率的ですが、データの状態が変わる可能性がある場合や、複数回列挙する場合は即時実行で結果を固定することが望ましいです。

変換メソッドが即時実行を引き起こすタイミング

LINQの変換メソッドであるToList、ToArray、ToDictionaryは、呼び出された時点でシーケンスの全要素を列挙し、即時に結果を生成します。

これにより、元のシーケンスの遅延実行の性質が打ち消され、結果がメモリ上に確定します。

例えば、以下のコードではToListが呼ばれた時点でnumbersの要素がすべて評価され、evenNumbersに格納されます。

int[] numbers = { 1, 2, 3, 4, 5 };
List<int> evenNumbers = numbers.Where(n => n % 2 == 0).ToList();
// ここで即時実行されているため、evenNumbersは確定したリスト

この即時実行のタイミングは、以下のようなケースで重要になります。

元のデータが変更される可能性がある場合、変換メソッドで結果を固定することで安定したデータを扱える
複数回列挙する場合に、毎回クエリを実行するコストを削減できる
データベースや外部リソースからのデータ取得時に、一度にまとめて取得したい場合

ただし、即時実行は全要素をメモリに読み込むため、大量データの場合はメモリ使用量に注意が必要です。

ReadOnlyCollectionへの変換オプション

LINQの標準メソッドには直接ReadOnlyCollection<T>を返すものはありませんが、ToListやToArrayで変換した後にReadOnlyCollection<T>に変換することが可能です。

ReadOnlyCollection<T>は読み取り専用のコレクションで、外部からの変更を防ぎたい場合に便利です。

以下はToListでリストを作成し、それをReadOnlyCollection<T>に変換する例です。

using System.Collections.ObjectModel;
int[] numbers = { 1, 2, 3, 4, 5 };
List<int> list = numbers.Where(n => n > 2).ToList();
ReadOnlyCollection<int> readOnlyList = new ReadOnlyCollection<int>(list);
// readOnlyListは読み取り専用で、要素の追加や削除はできない

ReadOnlyCollection<T>は内部的に元のリストを参照しているため、元のリストを変更するとReadOnlyCollection<T>の内容も変わります。

完全に不変のコレクションを作りたい場合は、ToArrayで配列に変換し、それをReadOnlyCollection<T>に渡す方法もあります。

メソッド	返却型	変更可否	メモリ使用量	主な用途
ToList	List<T>	変更可	中	要素の追加・削除が必要な場合
ToArray	T[]	変更不可	少	サイズ固定で高速アクセスが必要な場合
ReadOnlyCollection<T>	ReadOnlyCollection<T>	読み取り専用	中	外部からの変更を防ぎたい場合

このように、変換メソッドの結果をさらにReadOnlyCollection<T>に変換することで、用途に応じたコレクションの安全性や操作性を調整できます。

ToListの詳細

シンタックスと基本例

ToListメソッドは、IEnumerable<T>型のシーケンスをList<T>型に変換します。

呼び出すと即時実行され、結果がメモリ上のリストとして確定します。

基本的な使い方は以下の通りです。

var list = source.ToList();

ここでsourceはIEnumerable<T>型のシーケンスです。

ラムダ式を使ったフィルタリング後の変換

LINQのWhereメソッドなどで条件を指定し、フィルタリングした結果をToListでリストに変換する例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
        // 偶数だけを抽出してリストに変換
        List<int> evenNumbers = numbers.Where(n => n % 2 == 0).ToList();
        foreach (var num in evenNumbers)
        {
            Console.WriteLine(num);
        }
    }
}

2
4
6

このコードでは、numbersリストから偶数だけを抽出し、evenNumbersに格納しています。

ToListを使うことで、結果をリストとして扱い、要素の追加や削除が可能になります。

クエリ式からの変換

LINQのクエリ式(クエリ構文)を使ってフィルタリングし、ToListでリストに変換する例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        int[] numbers = { 10, 15, 20, 25, 30 };
        // 20以上の数値を抽出
        var query = from n in numbers
                    where n >= 20
                    select n;
        List<int> filteredList = query.ToList();
        foreach (var num in filteredList)
        {
            Console.WriteLine(num);
        }
    }
}

20
25
30

クエリ式で定義したqueryは遅延実行されますが、ToListを呼ぶことで即時実行され、結果がリストに格納されます。

Listの操作性メリット

List<T>は配列に比べて柔軟な操作が可能です。

主なメリットは以下の通りです。

要素の追加・削除が容易

AddやRemove、Insertなどのメソッドで動的に要素を操作できます。

インデックスアクセスが高速

配列と同様にインデックスで要素にアクセスでき、ランダムアクセスが高速です。

容量の自動拡張

内部的に容量が足りなくなると自動で拡張されるため、サイズを気にせず使えます。

LINQとの親和性

LINQの結果をすぐにリストとして扱い、さらに操作を加えられます。

例えば、ToListで変換した後に要素を追加するコードは以下の通りです。

var list = new List<int> { 1, 2, 3 };
list.Add(4);
Console.WriteLine(string.Join(", ", list));

1, 2, 3, 4

パフォーマンス特性

複数回列挙時のメリット

LINQのシーケンスは遅延実行のため、複数回列挙すると毎回クエリが実行されます。

ToListで結果をリストに変換すると、メモリ上に結果が確定するため、複数回の列挙でも高速にアクセスできます。

var numbers = Enumerable.Range(1, 1000000);
var filtered = numbers.Where(n => n % 2 == 0);
// 毎回Whereが実行される
int sum1 = filtered.Sum();
int count1 = filtered.Count();
// ToListで結果を確定
var list = filtered.ToList();
int sum2 = list.Sum();
int count2 = list.Count();

listを使う場合はWhereの処理が一度だけ実行されるため、複数回の集計処理が高速になります。

メモリ使用量への影響

ToListは全要素をメモリに読み込むため、元のシーケンスが大きい場合はメモリ使用量が増加します。

大量データを扱う際は注意が必要です。

必要な要素だけを抽出してからToListを使うか、遅延実行のまま処理を行うことを検討してください。

ジェネリック型制約の影響

ToListはジェネリックメソッドであり、IEnumerable<T>を受け取ってList<T>を返します。

Tは任意の型でよく、特に制約はありません。

ただし、Tが参照型か値型かによって挙動やパフォーマンスに違いが出ることがあります。

参照型の場合

リストは要素の参照を保持します。

要素の変更はリスト内のオブジェクトに反映されます。

値型の場合

値のコピーが行われるため、リスト内の要素を変更しても元の値には影響しません。

また、Tが複雑な型の場合は、コピーコストやメモリ使用量が増える可能性があります。

ToListを避けるべきケース

ToListは便利ですが、以下のようなケースでは避けることが望ましいです。

大量データを扱う場合

全要素をメモリに読み込むため、メモリ不足やパフォーマンス低下の原因になります。

一度しか列挙しない場合

遅延実行のまま処理したほうが効率的です。

変更不要な読み取り専用のコレクションが欲しい場合

ToListは変更可能なリストを返すため、読み取り専用のReadOnlyCollection<T>や配列を使うほうが安全です。

データベースクエリの途中で使う場合

ToListを呼ぶと即時実行されてしまい、クエリの最適化ができなくなることがあります。

代替としてAsList拡張メソッドを使うパターン

標準のLINQにはAsListメソッドはありませんが、独自に拡張メソッドを作成して、既にList<T>であれば変換を省略し、そうでなければToListを呼ぶパターンがあります。

これにより、不要なコピーを避けてパフォーマンスを向上できます。

以下はAsList拡張メソッドの例です。

using System.Collections.Generic;
using System.Linq;
public static class EnumerableExtensions
{
    public static List<T> AsList<T>(this IEnumerable<T> source)
    {
        if (source is List<T> list)
        {
            return list;
        }
        return source.ToList();
    }
}

使い方は以下の通りです。

var numbers = new List<int> { 1, 2, 3 };
var list1 = numbers.AsList(); // 既にListなのでコピーなし
var array = new int[] { 4, 5, 6 };
var list2 = array.AsList(); // 配列なのでToListが呼ばれる

この方法は、既にList<T>である場合に無駄なコピーを防ぎ、パフォーマンスを改善できます。

特に大規模データや頻繁に変換を行う場面で有効です。

ToArrayの詳細

シンタックスと基本例

ToArrayメソッドは、IEnumerable<T>型のシーケンスを配列T[]に変換します。

呼び出すと即時実行され、結果が固定サイズの配列としてメモリ上に確保されます。

基本的な使い方は以下の通りです。

var array = source.ToArray();

ここでsourceはIEnumerable<T>型のシーケンスです。

数値配列を生成するパターン

数値のシーケンスから配列を生成する例です。

Whereで条件を指定し、ToArrayで配列に変換しています。

using System;
using System.Linq;
class Program
{
    static void Main()
    {
        int[] numbers = { 1, 3, 5, 6, 8, 10 };
        // 偶数のみ抽出して配列に変換
        int[] evenNumbers = numbers.Where(n => n % 2 == 0).ToArray();
        foreach (var num in evenNumbers)
        {
            Console.WriteLine(num);
        }
    }
}

6
8
10

このコードでは、numbers配列から偶数だけを抽出し、evenNumbers配列に格納しています。

ToArrayを使うことで、結果を固定サイズの配列として扱えます。

文字列配列を生成するパターン

文字列のシーケンスから配列を生成する例です。

Selectで変換し、ToArrayで配列に変換しています。

using System;
using System.Linq;
class Program
{
    static void Main()
    {
        string[] words = { "apple", "banana", "cherry" };
        // すべて大文字に変換して配列に変換
        string[] upperWords = words.Select(w => w.ToUpper()).ToArray();
        foreach (var word in upperWords)
        {
            Console.WriteLine(word);
        }
    }
}

APPLE
BANANA
CHERRY

この例では、words配列の各要素を大文字に変換し、upperWords配列に格納しています。

パフォーマンス特性

配列アクセスの高速性

配列はメモリ上で連続した領域に格納されているため、インデックスアクセスが非常に高速です。

ToArrayで変換した配列は、List<T>や他のコレクションに比べてアクセス速度が速いことが多いです。

例えば、ループで大量の要素にアクセスする場合、配列の方がキャッシュ効率が良く、パフォーマンスが向上します。

int[] array = Enumerable.Range(1, 1000000).ToArray();
int sum = 0;
for (int i = 0; i < array.Length; i++)
{
    sum += array[i];
}
Console.WriteLine(sum);

このようなケースでは、配列の高速アクセスが効果的です。

サイズ固定による制約

配列は生成時にサイズが固定されるため、要素の追加や削除ができません。

ToArrayで変換した配列は不変のサイズを持つため、動的な要素操作が必要な場合はList<T>の方が適しています。

サイズ変更が必要な場合は、ToListでリストに変換してから操作し、必要に応じて再度ToArrayに変換する方法が一般的です。

Span<T>やMemory<T>との連携

Span<T>やMemory<T>は、配列やメモリ領域を効率的に扱うための構造体で、特にパフォーマンスが求められる場面で活用されます。

ToArrayで生成した配列は、Span<T>やMemory<T>の元データとして利用できます。

using System;
class Program
{
    static void Main()
    {
        int[] array = { 1, 2, 3, 4, 5 };
        Span<int> span = array.AsSpan();
        // Spanを使って一部の要素を変更
        span[0] = 10;
        foreach (var num in array)
        {
            Console.WriteLine(num);
        }
    }
}

この例では、arrayのデータをSpan<int>で参照し、Span経由で要素を変更しています。

ToArrayで作成した配列はSpanやMemoryと親和性が高く、効率的なメモリ操作が可能です。

Pinningの問題と安全なハンドリング

配列はガベージコレクション(GC)によって移動される可能性があるため、アンマネージコードやネイティブAPIと連携する際には「ピン留め(Pinning)」が必要です。

fixed文を使って配列のメモリ位置を固定し、安全にポインタを取得できます。

unsafe
{
    int[] array = { 1, 2, 3 };
    fixed (int* ptr = array)
    {
        // ptrは配列の先頭要素を指すポインタ
        Console.WriteLine(*ptr); // 1
    }
}

ピン留めはGCの移動を防ぐため、長時間ピン留めするとGCの効率が低下します。

必要な範囲だけピン留めし、すぐに解除することが推奨されます。

ToArrayを避けるべきケース

ToArrayは便利ですが、以下のような場合は使用を控えたほうが良いです。

大量データを扱う場合

全要素をメモリに読み込むため、メモリ消費が大きくなります。

遅延実行のまま処理するか、必要な部分だけを抽出してから変換してください。

動的な要素追加・削除が必要な場合

配列はサイズ固定なので、List<T>を使うほうが適しています。

頻繁に変換を繰り返す場合

毎回配列を生成するとパフォーマンスに影響が出るため、可能な限り再利用やキャッシュを検討してください。

データベースクエリの途中で使う場合

ToArrayを呼ぶと即時実行され、クエリの最適化が妨げられることがあります。

必要な場合のみ使いましょう。

ToDictionaryの詳細

シンタックスと基本例

ToDictionaryメソッドは、IEnumerable<T>型のシーケンスからキーと値のペアを生成し、Dictionary<TKey, TValue>型の辞書に変換します。

キーと値の選択方法を指定でき、即時実行されます。

基本的なシンタックスは以下の通りです。

var dictionary = source.ToDictionary(keySelector);
var dictionary = source.ToDictionary(keySelector, elementSelector);

keySelector：各要素からキーを抽出する関数
elementSelector(省略可能)：各要素から値を抽出する関数。省略時は要素自身が値になる

KeySelectorとElementSelectorの定義

キーと値の選択はラムダ式で指定します。

例えば、以下の例ではFruitクラスのNameをキー、Priceを値として辞書を作成しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Fruit
{
    public string Name { get; set; }
    public int Price { get; set; }
}
class Program
{
    static void Main()
    {
        var fruits = new List<Fruit>
        {
            new Fruit { Name = "Apple", Price = 100 },
            new Fruit { Name = "Banana", Price = 50 },
            new Fruit { Name = "Cherry", Price = 200 }
        };
        var fruitDictionary = fruits.ToDictionary(f => f.Name, f => f.Price);
        foreach (var kvp in fruitDictionary)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}円");
        }
    }
}

Apple: 100円
Banana: 50円
Cherry: 200円

この例では、f => f.Nameがキー選択子、f => f.Priceが値選択子です。

重複キー発生時の挙動

ToDictionaryはキーの重複を許容しません。

もしシーケンス内に同じキーが複数存在すると、ArgumentExceptionがスローされます。

var list = new[] { "apple", "banana", "apple" };
var dict = list.ToDictionary(s => s); // 例外発生

重複キーを扱いたい場合は、ToLookupを使うか、グルーピングしてから辞書に変換する方法を検討してください。

カスタムIEqualityComparerの利用

ToDictionaryはキーの比較にデフォルトのEqualityComparer<TKey>.Defaultを使いますが、独自の比較ロジックを指定することも可能です。

例えば、大文字・小文字を区別しない辞書を作る場合は以下のようにします。

var fruits = new[] { "Apple", "apple", "Banana" };
var dict = fruits.ToDictionary(
    keySelector: f => f,
    elementSelector: f => f.Length,
    comparer: StringComparer.OrdinalIgnoreCase);
foreach (var kvp in dict)
{
    Console.WriteLine($"{kvp.Key}: {kvp.Value}");
}

Apple: 5
Banana: 6

この例ではStringComparer.OrdinalIgnoreCaseを指定し、大文字・小文字を区別せずにキーを比較しています。

値がコレクションの場合の変換

値にコレクションを持つ辞書を作成する場合、ToDictionaryのelementSelectorでコレクションを生成できます。

例えば、複数の値をまとめて格納したいときに使います。

var fruits = new[]
{
    new { Category = "Red", Name = "Apple" },
    new { Category = "Red", Name = "Strawberry" },
    new { Category = "Yellow", Name = "Banana" }
};
var dict = fruits
    .GroupBy(f => f.Category)
    .ToDictionary(g => g.Key, g => g.Select(f => f.Name).ToList());
foreach (var kvp in dict)
{
    Console.WriteLine($"{kvp.Key}: {string.Join(", ", kvp.Value)}");
}

Red: Apple, Strawberry
Yellow: Banana

この例では、GroupByでカテゴリごとにグループ化し、ToDictionaryでカテゴリをキー、名前のリストを値にしています。

パフォーマンス特性

ルックアップ速度とメモリ

Dictionary<TKey, TValue>はハッシュテーブルを内部構造に持ち、キーによる高速なルックアップが可能です。

平均的にO(1)の検索速度を実現し、大量データの検索に適しています。

ただし、ハッシュテーブルの構築にはメモリが必要で、ToDictionaryは全要素を列挙して辞書を作成するため、メモリ使用量は元のシーケンスより増加します。

特にキーや値が大きなオブジェクトの場合は注意が必要です。

ToDictionary vs ToLookup

ToDictionaryと似たメソッドにToLookupがありますが、用途が異なります。

特徴	ToDictionary	ToLookup
キーの重複	許容しない(重複で例外発生)	許容する(複数の値を保持可能)
返却型	Dictionary<TKey, TValue>	ILookup<TKey, TElement>
値の型	単一の値	複数の値(コレクション)
変更可否	変更可能	読み取り専用
用途	一意のキーで高速検索	キーに複数の値が紐づく場合の検索

重複キーがある場合や、キーに複数の値を関連付けたい場合はToLookupを使い、単一の値を高速に検索したい場合はToDictionaryを使います。

ToDictionaryを避けるべきケース

重複キーが存在する可能性がある場合

例外が発生するため、事前に重複を排除するかToLookupを使うべきです。

大量データでメモリ使用量を抑えたい場合

辞書の構築はメモリを多く消費するため、必要な場合のみ使いましょう。

キーの比較に特殊なロジックが必要で、適切なIEqualityComparerが用意できない場合

意図しない動作やパフォーマンス低下の原因になります。

データベースクエリの途中で使う場合

即時実行されるため、クエリの最適化が妨げられることがあります。

GroupingからDictionaryへ変換する拡張メソッド

GroupByの結果はIGrouping<TKey, TElement>のシーケンスであり、そのままでは辞書として使いにくいことがあります。

GroupByの結果を辞書に変換する拡張メソッドを作成すると便利です。

using System.Collections.Generic;
using System.Linq;
public static class EnumerableExtensions
{
    public static Dictionary<TKey, List<TElement>> ToDictionaryFromGrouping<TKey, TElement>(
        this IEnumerable<IGrouping<TKey, TElement>> groupings)
    {
        return groupings.ToDictionary(g => g.Key, g => g.ToList());
    }
}

使い方は以下の通りです。

var fruits = new[]
{
    new { Category = "Red", Name = "Apple" },
    new { Category = "Red", Name = "Strawberry" },
    new { Category = "Yellow", Name = "Banana" }
};
var grouped = fruits.GroupBy(f => f.Category);
var dict = grouped.ToDictionaryFromGrouping();
foreach (var kvp in dict)
{
    Console.WriteLine($"{kvp.Key}: {string.Join(", ", kvp.Value.Select(f => f.Name))}");
}

Red: Apple, Strawberry
Yellow: Banana

この拡張メソッドは、グループ化した結果をキーとリストの辞書に変換し、扱いやすくします。

複数の値を持つキーを辞書で管理したい場合に役立ちます。

補助的変換メソッド

AsEnumerableでDB問い合わせをメモリへ切り替える

AsEnumerableメソッドは、LINQ to EntitiesやLINQ to SQLなどのデータベースクエリから、メモリ上のIEnumerable<T>に切り替えるために使います。

これにより、データベース側で実行できないメソッドや.NETのメソッドを適用できるようになります。

例えば、データベースから取得したエンティティに対して、LINQ to Entitiesではサポートされていないメソッドを使いたい場合にAsEnumerableを挟みます。

using System;
using System.Linq;
using System.Collections.Generic;
class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}
class Program
{
    static void Main()
    {
        // 仮想的なデータベースクエリ
        IQueryable<Product> products = GetProductsFromDb();
        // データベース側でToStringは使えないため、AsEnumerableでメモリ上に切り替え
        var query = products.AsEnumerable()
                            .Where(p => p.Price > 100)
                            .Select(p => new { p.Name, PriceString = p.Price.ToString("C") });
        foreach (var item in query)
        {
            Console.WriteLine($"{item.Name}: {item.PriceString}");
        }
    }
    static IQueryable<Product> GetProductsFromDb()
    {
        // 実際はDBからのクエリ。ここではサンプルデータを返す
        var list = new List<Product>
        {
            new Product { Name = "Laptop", Price = 1500 },
            new Product { Name = "Mouse", Price = 25 },
            new Product { Name = "Keyboard", Price = 75 }
        };
        return list.AsQueryable();
    }
}

Laptop: ¥1,500

この例では、AsEnumerableを使うことで、ToString("C")のような.NETのメソッドをメモリ上で安全に実行しています。

AsEnumerableはクエリの遅延実行を維持しつつ、以降の処理をLINQ to Objectsに切り替えます。

ToLookupで多値ディクショナリを生成

ToLookupは、キーに対して複数の値を持つコレクションを生成します。

ILookup<TKey, TElement>型を返し、1つのキーに複数の要素が紐づく場合に便利です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var fruits = new[]
        {
            new { Name = "Apple", Category = "Red" },
            new { Name = "Strawberry", Category = "Red" },
            new { Name = "Banana", Category = "Yellow" },
            new { Name = "Lemon", Category = "Yellow" }
        };
        var lookup = fruits.ToLookup(f => f.Category);
        foreach (var group in lookup)
        {
            Console.WriteLine($"{group.Key}: {string.Join(", ", group.Select(f => f.Name))}");
        }
    }
}

Red: Apple, Strawberry
Yellow: Banana, Lemon

ToLookupはToDictionaryと異なり、重複キーを許容し、キーごとに複数の値を保持します。

読み取り専用で変更はできませんが、グループ化されたデータの高速検索に適しています。

CastとOfTypeで型変換を行う

Cast<T>とOfType<T>は、非ジェネリックなIEnumerableや異なる型のコレクションから特定の型の要素を抽出・変換するためのメソッドです。

Cast<T>

コレクション内のすべての要素を指定した型にキャストします。

キャストできない要素があると例外が発生します。

using System;
using System.Collections;
class Program
{
    static void Main()
    {
        ArrayList list = new ArrayList { 1, 2, 3 };
        var numbers = list.Cast<int>();
        foreach (var num in numbers)
        {
            Console.WriteLine(num);
        }
    }
}

1
2
3

OfType<T>

指定した型にキャスト可能な要素だけを抽出します。

キャストできない要素は無視されます。

using System;
using System.Collections;
class Program
{
    static void Main()
    {
        ArrayList list = new ArrayList { 1, "two", 3, "four" };
        var numbers = list.OfType<int>();
        foreach (var num in numbers)
        {
            Console.WriteLine(num);
        }
    }
}

1
3

Cast<T>はすべての要素が対象型であることが保証されている場合に使い、OfType<T>は混在する型の中から特定の型だけを抽出したい場合に使います。

Selectで匿名型やタプルを生成

Selectメソッドは、シーケンスの各要素を変換して新しいシーケンスを生成します。

匿名型やタプルを生成する際に非常に便利です。

匿名型の生成

using System;
using System.Linq;
class Program
{
    static void Main()
    {
        var fruits = new[]
        {
            new { Name = "Apple", Price = 100 },
            new { Name = "Banana", Price = 50 }
        };
        var query = fruits.Select(f => new { f.Name, PriceWithTax = f.Price * 1.1 });
        foreach (var item in query)
        {
            Console.WriteLine($"{item.Name}: {item.PriceWithTax:F1}");
        }
    }
}

Apple: 110.0
Banana: 55.0

タプルの生成

using System;
using System.Linq;
class Program
{
    static void Main()
    {
        var fruits = new[]
        {
            new { Name = "Apple", Price = 100 },
            new { Name = "Banana", Price = 50 }
        };
        var query = fruits.Select(f => (f.Name, PriceWithTax: f.Price * 1.1));
        foreach (var item in query)
        {
            Console.WriteLine($"{item.Name}: {item.PriceWithTax:F1}");
        }
    }
}

Apple: 110.0
Banana: 55.0

匿名型は型名を持たず、プロパティ名でアクセスします。

タプルは名前付き要素を持つ構造体で、より軽量に扱えます。

どちらもSelectで簡単に生成でき、データの一時的な変換や集約に役立ちます。

パフォーマンス検証シナリオ

小規模データ(最大1,000件)

小規模データの範囲では、LINQの変換メソッドToList、ToArray、ToDictionaryのパフォーマンス差はほとんど体感できません。

処理時間はミリ秒単位以下で、メモリ使用量も少ないため、どのメソッドを使っても問題ありません。

ただし、頻繁に変換を繰り返す場合やリアルタイム性が求められるUI処理などでは、無駄なコピーを避けるために遅延実行を活用したり、必要な変換だけを行うことが望ましいです。

以下は小規模データでToListを使った例です。

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
class Program
{
    static void Main()
    {
        var data = Enumerable.Range(1, 1000);
        var sw = Stopwatch.StartNew();
        var list = data.Where(n => n % 2 == 0).ToList();
        sw.Stop();
        Console.WriteLine($"ToList処理時間: {sw.ElapsedMilliseconds} ms");
        Console.WriteLine($"要素数: {list.Count}");
    }
}

ToList処理時間: 0 ms
要素数: 500

中規模データ(最大100,000件)

中規模データでは、変換メソッドのパフォーマンス差が徐々に顕著になります。

ToArrayは配列の連続メモリ確保が必要なため、ToListより若干遅くなることがありますが、アクセス速度は速いです。

ToDictionaryはハッシュテーブルの構築コストが加わるため、最も時間がかかる傾向があります。

メモリ使用量も増加するため、不要な変換は避け、必要な変換だけを行うことが重要です。

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
class Program
{
    static void Main()
    {
        var data = Enumerable.Range(1, 100000);
        var sw = Stopwatch.StartNew();
        var array = data.Where(n => n % 2 == 0).ToArray();
        sw.Stop();
        Console.WriteLine($"ToArray処理時間: {sw.ElapsedMilliseconds} ms");
        sw.Restart();
        var list = data.Where(n => n % 2 == 0).ToList();
        sw.Stop();
        Console.WriteLine($"ToList処理時間: {sw.ElapsedMilliseconds} ms");
        sw.Restart();
        var dict = data.Where(n => n % 2 == 0).ToDictionary(n => n);
        sw.Stop();
        Console.WriteLine($"ToDictionary処理時間: {sw.ElapsedMilliseconds} ms");
    }
}

ToArray処理時間: 0 ms
ToList処理時間: 0 ms
ToDictionary処理時間: 2 ms

大規模データ(1,000,000件以上)

大規模データでは、変換メソッドのパフォーマンスとメモリ消費が顕著に影響します。

ToDictionaryはハッシュテーブルの構築に多くの時間とメモリを要し、ToArrayは連続した大きなメモリ領域を確保するため、メモリ断片化やGCの負荷が増加します。

このため、大規模データでは遅延実行を活用し、必要な部分だけを処理するか、変換後のコレクションを再利用する設計が望ましいです。

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
class Program
{
    static void Main()
    {
        var data = Enumerable.Range(1, 1_000_000);
        var sw = Stopwatch.StartNew();
        var array = data.Where(n => n % 2 == 0).ToArray();
        sw.Stop();
        Console.WriteLine($"ToArray処理時間: {sw.ElapsedMilliseconds} ms");
        sw.Restart();
        var list = data.Where(n => n % 2 == 0).ToList();
        sw.Stop();
        Console.WriteLine($"ToList処理時間: {sw.ElapsedMilliseconds} ms");
        sw.Restart();
        var dict = data.Where(n => n % 2 == 0).ToDictionary(n => n);
        sw.Stop();
        Console.WriteLine($"ToDictionary処理時間: {sw.ElapsedMilliseconds} ms");
    }
}

ToArray処理時間: 13 ms
ToList処理時間: 5 ms
ToDictionary処理時間: 19 ms

Stopwatchを用いたベンチマーク方法

Stopwatchクラスは高精度な時間計測が可能で、LINQの変換メソッドの処理時間を計測するのに適しています。

計測時はGCの影響を避けるため、事前にウォームアップを行い、複数回計測して平均を取ることが推奨されます。

using System;
using System.Diagnostics;
using System.Linq;
class Program
{
    static void Main()
    {
        var data = Enumerable.Range(1, 100000);
        // ウォームアップ
        var warmup = data.Where(n => n % 2 == 0).ToList();
        var sw = new Stopwatch();
        int iterations = 5;
        long totalElapsed = 0;
        for (int i = 0; i < iterations; i++)
        {
            sw.Restart();
            var list = data.Where(n => n % 2 == 0).ToList();
            sw.Stop();
            totalElapsed += sw.ElapsedMilliseconds;
        }
        Console.WriteLine($"平均処理時間: {totalElapsed / iterations} ms");
    }
}

メモリプロファイラでの確認

メモリ使用量の計測にはVisual Studioの診断ツールやJetBrains dotMemory、Redgate ANTS Memory Profilerなどのメモリプロファイラを使います。

これらを使うと、変換メソッド実行前後のヒープサイズやオブジェクトの割り当て状況を詳細に確認できます。

ヒープサイズの増加

ToListやToArrayは全要素をメモリに確保するため、ヒープサイズが大きく増加します。

オブジェクトの割り当て数

変換時に新しいコレクションが生成されるため、割り当て数が増えます。

メモリプロファイラを使うことで、どの変換メソッドがメモリに与える影響が大きいかを把握し、最適化の指針にできます。

GCコレクション回数の比較

GC(ガベージコレクション)の発生回数はパフォーマンスに大きく影響します。

大量のメモリ割り当てや大きなオブジェクトの生成はGCを頻繁に発生させ、処理の遅延を招きます。

ToListやToArrayは大量のメモリを確保するため、GCの発生回数が増える傾向があります。

GCの発生回数はGC.CollectionCountメソッドで取得可能です。

using System;
using System.Diagnostics;
using System.Linq;
class Program
{
    static void Main()
    {
        var data = Enumerable.Range(1, 1000000);
        long gen0Before = GC.CollectionCount(0);
        long gen1Before = GC.CollectionCount(1);
        long gen2Before = GC.CollectionCount(2);
        var list = data.Where(n => n % 2 == 0).ToList();
        long gen0After = GC.CollectionCount(0);
        long gen1After = GC.CollectionCount(1);
        long gen2After = GC.CollectionCount(2);
        Console.WriteLine($"Gen0 GC回数: {gen0After - gen0Before}");
        Console.WriteLine($"Gen1 GC回数: {gen1After - gen1Before}");
        Console.WriteLine($"Gen2 GC回数: {gen2After - gen2Before}");
    }
}

GCの発生回数が多い場合は、メモリ使用量の削減やオブジェクトの再利用を検討し、パフォーマンス改善を図ることが重要です。

エラーハンドリングと落とし穴

NullReferenceExceptionの対策

LINQの変換メソッドを使う際に、NullReferenceExceptionが発生する主な原因は、シーケンス自体やシーケンス内の要素がnullである場合です。

例えば、ToListやToArrayを呼ぶ前にnullチェックを怠ると例外が発生します。

List<string> list = null;
var result = list.Where(s => s.Length > 0).ToList(); // NullReferenceException発生

対策としては、以下の方法があります。

nullチェックを行う

if (list != null)
{
    var result = list.Where(s => s.Length > 0).ToList();
}
else
{
    // nullの場合の処理
}

null合体演算子を使う

var result = (list ?? Enumerable.Empty<string>()).Where(s => s.Length > 0).ToList();

要素のnullチェックを行う

シーケンス内の要素がnullの場合、WhereやSelectでアクセスすると例外になることがあります。

var list = new List<string> { "apple", null, "banana" };
var result = list.Where(s => s != null && s.Length > 0).ToList();

このように、要素がnullである可能性を考慮して条件を追加することが重要です。

ArgumentException(重複キー)の回避

ToDictionaryを使う際に、キーが重複しているとArgumentExceptionが発生します。

例えば、以下のコードは重複キーがあるため例外になります。

var fruits = new[] { "apple", "banana", "apple" };
var dict = fruits.ToDictionary(f => f); // ArgumentException発生

重複キーを回避する方法は以下の通りです。

重複を排除してから変換する

var dict = fruits.Distinct().ToDictionary(f => f);

グルーピングしてから辞書に変換する

var dict = fruits.GroupBy(f => f)
                 .ToDictionary(g => g.Key, g => g.First());

重複キーを許容するToLookupを使う

var lookup = fruits.ToLookup(f => f);

重複キーを許容しつつ最初の要素を使う拡張メソッドを作成する

public static Dictionary<TKey, TValue> ToDictionaryIgnoreDuplicates<TSource, TKey, TValue>(
    this IEnumerable<TSource> source,
    Func<TSource, TKey> keySelector,
    Func<TSource, TValue> elementSelector)
{
    var dict = new Dictionary<TKey, TValue>();
    foreach (var item in source)
    {
        var key = keySelector(item);
        if (!dict.ContainsKey(key))
        {
            dict[key] = elementSelector(item);
        }
    }
    return dict;
}

例外発生時の再試行ロジック

LINQの変換処理中に例外が発生した場合、再試行ロジックを組み込むことで一時的な問題を回避できることがあります。

特に外部リソースやネットワークアクセスを伴う場合に有効です。

以下は簡単な再試行ロジックの例です。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
public static class RetryHelper
{
    public static TResult Retry<TResult>(Func<TResult> func, int maxRetries, int delayMilliseconds)
    {
        int attempts = 0;
        while (true)
        {
            try
            {
                return func();
            }
            catch
            {
                attempts++;
                if (attempts >= maxRetries)
                    throw;
                Thread.Sleep(delayMilliseconds);
            }
        }
    }
}
class Program
{
    static void Main()
    {
        var data = new List<int> { 1, 2, 3 };
        var result = RetryHelper.Retry(() =>
        {
            // 例外が発生する可能性のある処理
            return data.Select(n => 10 / (n - 2)).ToList();
        }, maxRetries: 3, delayMilliseconds: 1000);
        foreach (var item in result)
        {
            Console.WriteLine(item);
        }
    }
}

この例では、Select内でゼロ除算の可能性があり、例外が発生すると最大3回まで再試行します。

再試行間隔は1秒です。

取り扱い注意の拡張メソッドチェーン

LINQの拡張メソッドはチェーンで記述することが多いですが、チェーン内で例外が発生すると原因の特定が難しくなることがあります。

特に以下の点に注意が必要です。

途中でnullが混入する可能性

チェーンの途中でnullが混入するとNullReferenceExceptionが発生しやすいです。

WhereやSelectで適切にnullチェックを入れましょう。

例外が発生しやすいメソッドの順序

例えば、Selectで複雑な変換を行う前にWhereでフィルタリングし、例外の発生範囲を狭めるとデバッグが容易になります。

例外処理をチェーン内に組み込むのは避ける

例外処理はチェーンの外側で行い、チェーン内は純粋な変換処理に留めるほうがコードの可読性と保守性が高まります。

デバッグ用に中間結果を変数に格納する

複雑なチェーンは途中の結果を変数に格納し、段階的に動作を確認するとトラブルシューティングがしやすくなります。

var filtered = source.Where(x => x != null);
var transformed = filtered.Select(x => x.Property);
var list = transformed.ToList();

このように分割することで、どの段階で問題が起きているかを特定しやすくなります。

実践ユースケース

APIレスポンスをListへ変換してキャッシュ

APIから取得したデータは通常、IEnumerable<T>やIQueryable<T>の形で受け取ることが多いですが、複数回アクセスする場合はToListでリストに変換してキャッシュするのが効果的です。

これにより、API呼び出しの回数を減らし、パフォーマンスを向上させられます。

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;
using System.Linq;
class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}
class Program
{
    static List<User> cachedUsers;
    static async Task Main()
    {
        await FetchAndCacheUsersAsync();
        // 複数回のアクセスでもAPI呼び出しは1回だけ
        var admins = cachedUsers.Where(u => u.Name.StartsWith("A")).ToList();
        var userCount = cachedUsers.Count;
        Console.WriteLine($"管理者数: {admins.Count}");
        Console.WriteLine($"ユーザー総数: {userCount}");
    }
    static async Task FetchAndCacheUsersAsync()
    {
        using var client = new HttpClient();
        var response = await client.GetStringAsync("https://api.example.com/users");
        var users = JsonSerializer.Deserialize<IEnumerable<User>>(response);
        // IEnumerable<User>をList<User>に変換してキャッシュ
        cachedUsers = users?.ToList() ?? new List<User>();
    }
}

この例では、APIから取得したユーザー情報をToListでリストに変換し、cachedUsersに保存しています。

以降の処理はキャッシュされたリストを使うため、APIへの不要なアクセスを防げます。

CSV読み込み後のDictionary化で高速検索

CSVファイルから読み込んだデータをToDictionaryで辞書に変換すると、キーによる高速な検索が可能になります。

例えば、商品コードをキーにして商品情報を管理するケースです。

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
class Product
{
    public string Code { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}
class Program
{
    static void Main()
    {
        var lines = File.ReadAllLines("products.csv");
        var products = lines.Skip(1) // ヘッダー行をスキップ
            .Select(line =>
            {
                var parts = line.Split(',');
                return new Product
                {
                    Code = parts[0],
                    Name = parts[1],
                    Price = decimal.Parse(parts[2])
                };
            });
        // 商品コードをキーにした辞書に変換
        var productDict = products.ToDictionary(p => p.Code);
        // 商品コードで高速検索
        if (productDict.TryGetValue("P123", out var product))
        {
            Console.WriteLine($"商品名: {product.Name}, 価格: {product.Price}");
        }
    }
}

このコードでは、CSVの各行をProductオブジェクトに変換し、ToDictionaryで商品コードをキーにした辞書を作成しています。

これにより、商品コードによる検索が高速に行えます。

設定ファイルパラメータの即時変換

設定ファイルのパラメータを読み込んだ後、ToDictionaryやToListで即時に変換しておくと、後続の処理で高速かつ安全にアクセスできます。

特にキーによる検索や複数回のアクセスがある場合に有効です。

using System;
using System.Collections.Generic;
using System.Linq;
class ConfigParameter
{
    public string Key { get; set; }
    public string Value { get; set; }
}
class Program
{
    static void Main()
    {
        var configParams = new[]
        {
            new ConfigParameter { Key = "Timeout", Value = "30" },
            new ConfigParameter { Key = "MaxRetries", Value = "5" },
            new ConfigParameter { Key = "EnableLogging", Value = "true" }
        };
        // 配列から辞書に変換
        var configDict = configParams.ToDictionary(p => p.Key, p => p.Value);
        // 設定値を取得
        if (configDict.TryGetValue("Timeout", out var timeout))
        {
            Console.WriteLine($"タイムアウト設定: {timeout}秒");
        }
    }
}

この例では、設定パラメータの配列を辞書に変換し、キーで素早く値を取得しています。

即時変換により、設定の読み込み後は高速なアクセスが可能です。

Xamarin・Unityでのモバイル環境最適化

モバイル環境ではメモリやCPUリソースが限られているため、LINQの変換メソッドを使う際はパフォーマンスに注意が必要です。

ToListやToArrayで不要なコピーを避け、必要なタイミングでのみ変換を行うことが重要です。

例えば、Unityでゲーム内のアイテムリストをフィルタリングして表示する場合、以下のように遅延実行を活用しつつ、必要な時にだけToListで変換します。

using System.Collections.Generic;
using System.Linq;
using UnityEngine;
public class Item
{
    public string Name;
    public bool IsEquipped;
}
public class Inventory : MonoBehaviour
{
    private List<Item> allItems;
    void Start()
    {
        allItems = new List<Item>
        {
            new Item { Name = "Sword", IsEquipped = true },
            new Item { Name = "Shield", IsEquipped = false },
            new Item { Name = "Potion", IsEquipped = false }
        };
    }
    public List<Item> GetUnequippedItems()
    {
        // 遅延実行のままフィルタリング
        var query = allItems.Where(item => !item.IsEquipped);
        // UI表示などで複数回アクセスする場合はToListで変換
        return query.ToList();
    }
}

このように、必要な時にだけToListを使い、無駄なメモリ消費を抑えつつパフォーマンスを確保します。

WebAPIのクエリ結果を配列として返す

WebAPIのレスポンスとして配列を返すケースでは、ToArrayを使って即時に配列に変換することが多いです。

配列はサイズが固定でシリアライズが高速なため、APIのレスポンスとして適しています。

using System;
using System.Linq;
using Microsoft.AspNetCore.Mvc;
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
}
[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private static readonly Product[] products = new[]
    {
        new Product { Id = 1, Name = "Laptop" },
        new Product { Id = 2, Name = "Mouse" },
        new Product { Id = 3, Name = "Keyboard" }
    };
    [HttpGet]
    public Product[] Get()
    {
        // LINQでフィルタリングし、配列に変換して返す
        return products.Where(p => p.Id > 1).ToArray();
    }
}

この例では、products配列からIDが1より大きい商品を抽出し、ToArrayで配列に変換してAPIレスポンスとして返しています。

配列はJSONシリアライズ時に扱いやすく、クライアント側でも効率的に処理できます。

コードメンテナンスのコツ

変換処理を拡張メソッドでラップする

LINQの変換処理を直接コード内に書くと、複雑なクエリが散在し、可読性や保守性が低下します。

そこで、変換処理を拡張メソッドとしてラップすることで、コードの再利用性を高め、読みやすく整理できます。

例えば、特定の条件でフィルタリングしリストに変換する処理を拡張メソッドにまとめる例です。

using System.Collections.Generic;
using System.Linq;
public static class EnumerableExtensions
{
    public static List<T> FilterActiveAndToList<T>(this IEnumerable<T> source, System.Func<T, bool> isActivePredicate)
    {
        return source.Where(isActivePredicate).ToList();
    }
}

使い方は以下の通りです。

var users = new List<User>
{
    new User { Name = "Alice", IsActive = true },
    new User { Name = "Bob", IsActive = false }
};
var activeUsers = users.FilterActiveAndToList(u => u.IsActive);

このように拡張メソッドで処理を切り出すと、呼び出し側はシンプルになり、変換ロジックの変更も一箇所で済みます。

クエリ分割で可読性向上

複雑なLINQクエリは一行で書くと読みにくくなりがちです。

クエリを複数の段階に分割し、途中結果を変数に格納することで可読性を向上させられます。

var filtered = users.Where(u => u.IsActive);
var ordered = filtered.OrderBy(u => u.Name);
var resultList = ordered.ToList();

このように段階的に処理を分けると、各処理の意味が明確になり、デバッグや修正も容易になります。

また、途中の変数にブレークポイントを設定して動作確認がしやすくなります。

再利用可能なメソッドチェーン

LINQのメソッドチェーンは柔軟ですが、同じ処理を複数箇所で使う場合は、再利用可能なメソッドとして切り出すと効率的です。

特に複数の変換やフィルタリングを組み合わせた処理は、メソッドチェーンを返すメソッドにまとめると便利です。

public static IQueryable<User> GetActiveUsersOrderedByName(IQueryable<User> source)
{
    return source.Where(u => u.IsActive)
                 .OrderBy(u => u.Name);
}

呼び出し側では以下のように使えます。

var activeUsers = GetActiveUsersOrderedByName(dbContext.Users).ToList();

この方法は、データソースが変わっても同じ処理を適用でき、コードの重複を減らせます。

Unitテストで変換ロジックを保証

変換処理はビジネスロジックの一部であり、正確に動作することが重要です。

Unitテストを用いて、変換ロジックが期待通りに動作することを保証しましょう。

例えば、拡張メソッドのテスト例です。

using NUnit.Framework;
using System.Collections.Generic;
using System.Linq;
[TestFixture]
public class EnumerableExtensionsTests
{
    [Test]
    public void FilterActiveAndToList_ReturnsOnlyActiveItems()
    {
        var users = new List<User>
        {
            new User { Name = "Alice", IsActive = true },
            new User { Name = "Bob", IsActive = false }
        };
        var result = users.FilterActiveAndToList(u => u.IsActive);
        Assert.AreEqual(1, result.Count);
        Assert.AreEqual("Alice", result[0].Name);
    }
}