配列&コレクション

【C#】KeyValuePair×List活用術：順序を保ちつつキーと値を操作するベストプラクティス

2025-05-16更新日: 2025-05-16

List<KeyValuePair<TKey,TValue>>は、要素の追加順を保持したままキーと値を扱えるコレクションです。

Addで登録し、FindやRemoveAllで検索・削除、Sortでキーや値基準の並べ替えができます。

LINQと組み合わせると抽出や集計も柔軟に行え、少量データならDictionaryとの差も気になりません。

目次から探す

KeyValuePairとListの基本
List<KeyValuePair>を選ぶ理由
List<KeyValuePair>の生成と初期化
要素追加と更新
- AddとAddRangeの使い分け
- インデクサによる上書き
検索と抽出
並べ替え
グルーピングと集計
- LINQ GroupByでカテゴリ別まとめ
- ToDictionaryへの変換パターン
削除とクリア
LINQと拡張メソッド活用
パフォーマンス最適化
スレッドセーフ対策
- lockでの排他制御
- ConcurrentBag<KeyValuePair<,>>への置き換え
イミュータブル設計への応用
- ReadOnlyCollection<KeyValuePair<,>>の利用
- Record型での代替実装
実践シナリオ別サンプル
エラー処理と例外ハンドリング
- ArgumentNullExceptionの回避
- キー未存在時の安全なアクセス方法
型制約とジェネリックの理解
- where TKey : notnullの意味
- Nullableキー使用時のリスク
ユニットテスト視点
- 期待順序の検証パターン
- テストデータ生成ヘルパ実装
リファクタリングと可読性向上
- メソッドチェーンの整理
- ジェネリック再利用による重複削減
まとめ

KeyValuePairとListの基本

C#でキーと値のペアを扱う際に非常に便利な構造体がKeyValuePair<TKey, TValue>です。

これをListと組み合わせることで、順序を保ちながらキーと値のペアを管理できます。

ここでは、KeyValuePairの特徴やアクセス方法、そしてDictionaryとの違いについて詳しく解説します。

構造体KeyValuePair<TKey,TValue>の特徴

KeyValuePair<TKey, TValue>は、名前の通り「キー」と「値」のペアを表す構造体です。

ジェネリック型であり、TKeyがキーの型、TValueが値の型を指定します。

主にDictionary<TKey, TValue>の内部で使われていますが、単独で使うことも可能です。

この構造体の特徴は以下の通りです。

不変(イミュータブル)

KeyとValueは読み取り専用のプロパティであり、一度作成したペアのキーや値を変更できません。

これにより、データの整合性が保たれやすくなります。

軽量な構造体

クラスではなく構造体であるため、ヒープではなくスタックに割り当てられることが多く、パフォーマンス面で有利な場合があります。

ただし、大量に扱う場合はボックス化に注意が必要です。

シンプルな構造

キーと値のペアを表すだけのシンプルな構造で、余計な機能は持ちません。

これにより、用途に応じて柔軟に使えます。

比較やハッシュコードの実装

EqualsやGetHashCodeがオーバーライドされているため、コレクション内での比較や検索に利用できます。

例えば、KeyValuePair<string, int>は文字列をキーに整数を値として持つペアを表します。

キーと値へのアクセス方法

KeyValuePair<TKey, TValue>のインスタンスを作成すると、KeyプロパティとValueプロパティを通じてそれぞれの値にアクセスできます。

これらは読み取り専用で、以下のように使います。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // KeyValuePairの作成
        var pair = new KeyValuePair<string, int>("Orange", 10);
        // キーと値の取得
        Console.WriteLine($"Key: {pair.Key}");   // 出力: Key: Orange
        Console.WriteLine($"Value: {pair.Value}"); // 出力: Value: 10
    }
}

Key: Orange
Value: 10

この例では、pair.Keyでキーの”Orange”を、pair.Valueで値の10を取得しています。

KeyValuePairは読み取り専用なので、pair.Key = "Apple"のような代入はできません。

また、List<KeyValuePair<TKey, TValue>>のようにリストで管理する場合は、リストの各要素に対して同様にKeyとValueを参照できます。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5)
        };
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

Key: Apple, Value: 3
Key: Banana, Value: 5

このように、KeyValuePairのKeyとValueは簡単にアクセスでき、リストの中でも順序を保ったままキーと値のペアを扱えます。

Dictionaryとの違いと併用ポイント

KeyValuePair<TKey, TValue>はDictionary<TKey, TValue>の内部で使われることが多いですが、List<KeyValuePair<TKey, TValue>>とDictionary<TKey, TValue>は用途や特性が異なります。

ここでは両者の違いと、併用時のポイントを説明します。

項目	List<KeyValuePair<TKey, TValue>>	Dictionary<TKey, TValue>
順序保持	順序を保持する(挿入順)	順序は保証されない(.NET Core 3.0以降は挿入順を保持するが仕様としては非保証)
キーの重複	キーの重複を許す	キーは一意でなければならない
検索速度	線形探索(O(n))	ハッシュテーブルによる高速検索(平均O(1))
追加・削除のコスト	追加は高速、削除は線形探索が必要	追加・削除とも高速
用途	順序を重視し、重複キーを許容したい場合	高速なキー検索と一意のキー管理が必要な場合

使い分けのポイント

順序を重視したい場合

順序を保ちながらキーと値のペアを管理したい場合はList<KeyValuePair<TKey, TValue>>が適しています。

例えば、ユーザーの入力順や設定ファイルの記述順を保持したいケースです。

キーの重複を許容したい場合

同じキーが複数存在しても問題ない場合はリストが便利です。

Dictionaryはキーの重複を許さないため、重複キーを扱う場合はリストを使います。

高速な検索が必要な場合

キーによる高速な検索や更新が必要な場合はDictionaryが適しています。

大量のデータを扱う場合は特に有効です。

併用シナリオ

順序を保持しつつ高速検索も必要な場合は、List<KeyValuePair<TKey, TValue>>で順序を管理しつつ、Dictionary<TKey, TValue>を別途用意してインデックスとして使う方法もあります。

ただし、同期の管理が必要になるため注意が必要です。

例：DictionaryからList<KeyValuePair>への変換

Dictionaryの内容を順序付きで扱いたい場合、ToList()メソッドで簡単に変換できます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var dict = new Dictionary<string, int>()
        {
            {"Apple", 3},
            {"Banana", 5},
            {"Cherry", 2}
        };
        // DictionaryをList<KeyValuePair>に変換
        var list = dict.ToList();
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

Key: Apple, Value: 3
Key: Banana, Value: 5
Key: Cherry, Value: 2

このように、Dictionaryの内容をリストに変換して順序を操作したり、重複キーを許容したりすることが可能です。

以上のように、KeyValuePair<TKey, TValue>はキーと値のペアを表すシンプルで使いやすい構造体です。

List<KeyValuePair<TKey, TValue>>と組み合わせることで、順序を保ちながら柔軟にデータを管理できます。

Dictionaryとの違いを理解し、用途に応じて使い分けることが効率的なプログラム作成につながります。

List<KeyValuePair>を選ぶ理由

順序保持のメリット

List<KeyValuePair<TKey, TValue>>を使う最大の利点は、要素の順序を保持できることです。

Dictionary<TKey, TValue>は高速な検索が可能ですが、基本的に順序を保証しません(.NET Core 3.0以降は挿入順を保持する仕様になりましたが、依然として順序に依存する設計は推奨されません)。

一方、List<KeyValuePair>は追加した順番そのままに要素を保持します。

順序保持が重要なケースは以下のような場面です。

ユーザー入力の履歴管理

ユーザーが入力した順番をそのまま保存し、後で順番通りに処理や表示を行いたい場合。

設定ファイルやCSVの読み込み

ファイルの行順や記述順を尊重しつつ、キーと値のペアを管理したいとき。

UI表示の並び替え前の状態保持

表示順を変える前の元の順序を保持し、必要に応じて復元したい場合。

重複キーを許容しつつ順序を管理

同じキーが複数存在する可能性がある場合、Dictionaryではキーの重複が許されないため、List<KeyValuePair>が適しています。

順序を保持することで、データの意味や文脈を損なわずに扱えるため、特にユーザー体験やデータの整合性が重要なアプリケーションで重宝します。

データ量とパフォーマンスの関係

List<KeyValuePair<TKey, TValue>>は内部的に配列を使って要素を管理しているため、要素の追加は高速です。

ただし、検索や削除は線形探索(O(n))になるため、データ量が増えるとパフォーマンスに影響が出やすくなります。

小～中規模のデータ

数百～数千件程度のデータであれば、List<KeyValuePair>の線形探索でも十分高速に動作します。

順序保持のメリットを活かしつつ、シンプルなコードで管理できます。

大規模データ

数万件以上の大量データを扱う場合は、検索や削除のたびにリスト全体を走査するため、パフォーマンスが低下します。

この場合はDictionaryやSortedDictionaryなどのハッシュベースや木構造のコレクションを検討したほうが良いです。

頻繁な更新がある場合

頻繁に要素の追加・削除・検索を行う場合は、Listの線形探索がボトルネックになることがあります。

更新頻度が低く、読み取りが多い場合は問題になりにくいです。

メモリ効率

List<KeyValuePair>は配列ベースなのでメモリの連続性が高く、キャッシュ効率が良いという利点もあります。

ただし、構造体であるKeyValuePairのサイズやボックス化に注意が必要です。

代替コレクション比較

List<KeyValuePair<TKey, TValue>>の代わりに使えるコレクションはいくつかありますが、それぞれ特徴が異なります。

用途に応じて適切なコレクションを選ぶことが重要です。

コレクション	順序保持	キー重複許可	検索速度	主な用途
`List<KeyValuePair<TKey, TValue>>`	あり(挿入順)	あり	線形探索(O(n))	順序重視、重複キー許容、小～中規模データ
`Dictionary<TKey, TValue>`	なし(.NET Core 3.0以降は挿入順保持)	なし(一意のキー)	高速(平均O(1))	高速検索、一意キー管理、大規模データ
`SortedDictionary<TKey, TValue>`	あり(キーの昇順)	なし	高速(O(log n))	ソート済みデータ管理、範囲検索
`SortedList<TKey, TValue>`	あり(キーの昇順)	なし	高速(O(log n))	ソート済みデータ、読み取り多め
`LinkedList<KeyValuePair<TKey, TValue>>`	あり(挿入順)	あり	線形探索(O(n))	順序重視、頻繁な挿入・削除
`ObservableCollection<KeyValuePair<TKey, TValue>>`	あり	あり	線形探索(O(n))	UIバインディング向け

代表的な代替例の特徴

Dictionary<TKey, TValue>

高速なキー検索が必要な場合に最適です。

ただし、キーの重複は許されず、順序は基本的に保証されません。

SortedDictionary<TKey, TValue> / SortedList<TKey, TValue>

キーの昇順で自動的にソートされるため、ソート済みのデータ管理に向いています。

検索は高速ですが、挿入や削除はListよりコストがかかる場合があります。

LinkedList<KeyValuePair<TKey, TValue>>

順序を保持しつつ、リストの途中への挿入や削除が高速です。

ただし、検索は線形探索になるため、大量データには不向きです。

ObservableCollection<KeyValuePair<TKey, TValue>>

UIのデータバインディングに適しており、コレクションの変更通知が可能です。

順序保持と重複キー許容もできますが、パフォーマンスはListとほぼ同等です。

List<KeyValuePair<TKey, TValue>>は順序を保ちつつ重複キーを許容できるため、特定のシナリオで非常に有効です。

ただし、データ量や操作頻度によっては他のコレクションのほうが適している場合もあります。

用途に応じて適切なコレクションを選択し、パフォーマンスと機能のバランスを考慮することが重要です。

List<KeyValuePair>の生成と初期化

空リストのインスタンス化

List<KeyValuePair<TKey, TValue>>を使う際、まずは空のリストを作成することが多いです。

空リストのインスタンス化は非常にシンプルで、以下のように記述します。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // 空のList<KeyValuePair<string, int>>を作成
        var list = new List<KeyValuePair<string, int>>();
        Console.WriteLine($"リストの初期要素数: {list.Count}"); // 出力: 0
    }
}

リストの初期要素数: 0

このコードでは、string型のキーとint型の値を持つ空のリストを作成しています。

Countプロパティは0で、まだ要素は一つも入っていません。

空リストは後からAddメソッドで要素を追加する際のベースとして使います。

コレクション初期化子を使った例

リストを生成すると同時に複数のKeyValuePairを初期化したい場合は、コレクション初期化子を使うとコードがすっきりします。

以下のように記述します。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // コレクション初期化子でリストを作成し、要素を追加
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

Key: Apple, Value: 3
Key: Banana, Value: 5
Key: Cherry, Value: 2

この例では、リストの生成と同時に3つのKeyValuePairを追加しています。

コレクション初期化子は可読性が高く、初期データが決まっている場合に便利です。

なお、KeyValuePairは構造体なので、newキーワードを省略することはできません。

必ずnew KeyValuePair<TKey, TValue>(key, value)の形で初期化してください。

容量指定でのメモリ最適化

List<T>は内部的に配列を使って要素を管理しており、要素が増えると自動的に配列のサイズを拡張します。

しかし、拡張時には新しい配列を確保して既存の要素をコピーするため、パフォーマンスに影響を与えることがあります。

大量の要素を追加することが分かっている場合は、コンストラクタで初期容量(Capacity)を指定しておくと、メモリの再確保やコピー回数を減らせます。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // 初期容量を10に指定してリストを作成
        var list = new List<KeyValuePair<string, int>>(10);
        // 10個の要素を追加
        for (int i = 0; i < 10; i++)
        {
            list.Add(new KeyValuePair<string, int>($"Key{i}", i));
        }
        Console.WriteLine($"リストの容量: {list.Capacity}"); // 出力: 10以上
        Console.WriteLine($"リストの要素数: {list.Count}"); // 出力: 10
    }
}

リストの容量: 10
リストの要素数: 10

このコードでは、初期容量を10に指定してリストを作成しています。

これにより、10個の要素を追加しても内部配列の再確保は発生しません。

容量はCapacityプロパティで確認でき、Countは実際の要素数を示します。

容量指定は特に大量データを扱う場合や、パフォーマンスを意識した処理で効果的です。

容量を適切に設定することで、不要なメモリ再確保を防ぎ、処理速度の安定化につながります。

要素追加と更新

AddとAddRangeの使い分け

List<KeyValuePair<TKey, TValue>>に要素を追加する際、単一の要素を追加する場合はAddメソッドを使い、複数の要素を一括で追加したい場合はAddRangeメソッドを使うのが基本です。

Addメソッド

単一のKeyValuePairをリストの末尾に追加します。

例えば、ユーザーの操作やイベントで1件ずつ追加する場合に適しています。

AddRangeメソッド

別のコレクション(配列やリストなど)から複数のKeyValuePairをまとめて追加します。

大量のデータを一度に追加したい場合や、外部から取得した複数のペアを一括で追加する際に便利です。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>();
        // Addで単一要素を追加
        list.Add(new KeyValuePair<string, int>("Apple", 3));
        // AddRangeで複数要素を追加
        var additionalItems = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        list.AddRange(additionalItems);
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

Key: Apple, Value: 3
Key: Banana, Value: 5
Key: Cherry, Value: 2

この例では、Addで1件、AddRangeで複数件を追加しています。

AddRangeは内部的に一度に容量を確保し、効率的に追加できるため、大量追加時のパフォーマンスが向上します。

複数追加時のベストプラクティス

複数の要素を追加する際は、以下のポイントを押さえると効率的です。

事前に容量を確保する

大量の要素を追加する場合は、Listの初期容量をCapacityで設定しておくと、内部配列の再確保を減らせます。

AddRangeを使う

ループでAddを繰り返すより、AddRangeでまとめて追加したほうがパフォーマンスが良いです。

追加元のコレクションを用意する

追加する要素を一旦別のリストや配列にまとめてからAddRangeで追加すると、コードの可読性も向上します。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>(100); // 事前に容量確保
        var newItems = new List<KeyValuePair<string, int>>();
        for (int i = 0; i < 50; i++)
        {
            newItems.Add(new KeyValuePair<string, int>($"Key{i}", i));
        }
        // AddRangeで一括追加
        list.AddRange(newItems);
        Console.WriteLine($"追加後の要素数: {list.Count}"); // 出力: 50
    }
}

追加後の要素数: 50

このように、容量確保とAddRangeの組み合わせで効率的に複数要素を追加できます。

インデクサによる上書き

List<T>はインデクサを使って特定のインデックスの要素を直接上書きできます。

List<KeyValuePair<TKey, TValue>>でも同様で、既存の要素を新しいKeyValuePairで置き換えることが可能です。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5)
        };
        // インデクサで要素を上書き
        list[1] = new KeyValuePair<string, int>("Banana", 10);
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

Key: Apple, Value: 3
Key: Banana, Value: 10

この例では、インデックス1の要素を新しい値で上書きしています。

インデクサは範囲外のインデックスを指定すると例外が発生するため、事前にCountを確認するか、例外処理を行うことが望ましいです。

条件一致でのバルク更新

複数の要素の値を条件に応じて一括で更新したい場合は、forループやforEachではなくforループを使ってインデクサで直接上書きする方法が効率的です。

foreachではコレクションの要素を直接変更できないためです。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Banana", 7),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        // キーが"Banana"の要素の値を10に更新
        for (int i = 0; i < list.Count; i++)
        {
            if (list[i].Key == "Banana")
            {
                list[i] = new KeyValuePair<string, int>(list[i].Key, 10);
            }
        }
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

Key: Apple, Value: 3
Key: Banana, Value: 10
Key: Banana, Value: 10
Key: Cherry, Value: 2

このコードでは、キーが”Banana”のすべての要素の値を10に更新しています。

forループでインデクサを使うことで、リストの要素を安全かつ効率的に上書きできます。

検索と抽出

Find・FindIndexの活用

List<KeyValuePair<TKey, TValue>>で特定の条件に合致する要素を検索する際、FindメソッドとFindIndexメソッドは非常に便利です。

Findメソッド

条件に合致する最初の要素を返します。

見つからなければ既定値default(KeyValuePair<TKey, TValue>)を返します。

FindIndexメソッド

条件に合致する最初の要素のインデックスを返します。

見つからなければ-1を返します。

例えば、キーが”Cherry”の要素を検索する場合は以下のように使います。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        // Findでキーが"Cherry"の要素を取得
        var found = list.Find(kvp => kvp.Key == "Cherry");
        if (!found.Equals(default(KeyValuePair<string, int>)))
        {
            Console.WriteLine($"Found: Key = {found.Key}, Value = {found.Value}");
        }
        else
        {
            Console.WriteLine("Not found");
        }
        // FindIndexでキーが"Banana"の要素のインデックスを取得
        int index = list.FindIndex(kvp => kvp.Key == "Banana");
        Console.WriteLine($"Index of Banana: {index}");
    }
}

Found: Key = Cherry, Value = 2
Index of Banana: 1

Findは最初に条件を満たす要素を返すため、複数該当しても最初の1件だけ取得したい場合に適しています。

FindIndexは要素の位置を知りたいときに使います。

LINQ Where・First・Singleの選択基準

LINQを使うと、より柔軟で表現力豊かな検索や抽出が可能です。

Where、First、Singleはよく使われるメソッドですが、使い分けが重要です。

Where

条件に合致するすべての要素を列挙します。

複数該当する場合に使います。

First / FirstOrDefault

条件に合致する最初の要素を取得します。

Firstは該当なしの場合に例外を投げますが、FirstOrDefaultは既定値を返します。

Single / SingleOrDefault

条件に合致する要素が1件だけであることを期待する場合に使います。

複数件あると例外が発生します。

SingleOrDefaultは該当なしの場合に既定値を返します。

使い分けのポイントは以下の通りです。

メソッド	複数該当時の挙動	該当なし時の挙動	主な用途
`Where`	すべて取得	空の列挙	複数該当を取得したい場合
`First`	最初の1件取得	例外発生	少なくとも1件あることが前提
`FirstOrDefault`	最初の1件取得	既定値返却	該当なしも許容する場合
`Single`	1件以外は例外	例外発生	1件だけ存在することが保証されている場合
`SingleOrDefault`	1件以外は例外	既定値返却	0か1件だけ存在する場合

例として、キーが”Banana”の最初の要素を取得するコードは以下の通りです。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Banana", 7),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        // FirstOrDefaultで最初の"Banana"を取得
        var firstBanana = list.FirstOrDefault(kvp => kvp.Key == "Banana");
        if (!firstBanana.Equals(default(KeyValuePair<string, int>)))
        {
            Console.WriteLine($"First Banana: Value = {firstBanana.Value}");
        }
        // Whereで全ての"Banana"を取得
        var allBananas = list.Where(kvp => kvp.Key == "Banana");
        Console.WriteLine("All Bananas:");
        foreach (var kvp in allBananas)
        {
            Console.WriteLine($"Value = {kvp.Value}");
        }
    }
}

First Banana: Value = 5
All Bananas:
Value = 5
Value = 7

このように、複数該当する可能性がある場合はWhereで全件取得し、最初の1件だけ欲しい場合はFirstやFirstOrDefaultを使います。

キー重複時の優先順位

List<KeyValuePair<TKey, TValue>>はキーの重複を許容するため、同じキーが複数存在することがあります。

検索や抽出の際にどの要素が優先されるかは、使用するメソッドや検索方法によって異なります。

FindやFirst系メソッド

リストの先頭から順に検索し、条件に合致した最初の要素を返します。

つまり、最も早く追加された(インデックスが小さい)要素が優先されます。

FindLastやLast系メソッド

リストの末尾から逆順に検索し、条件に合致した最初の要素を返します。

つまり、最も遅く追加された(インデックスが大きい)要素が優先されます。

Whereで複数取得

条件に合致するすべての要素を順序通りに取得します。

重複キーのすべてを扱いたい場合に使います。

例えば、以下のコードではキー”Banana”が2件ありますが、Findは最初の1件を返します。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 7)
        };
        var firstBanana = list.Find(kvp => kvp.Key == "Banana");
        Console.WriteLine($"Findで取得したBananaの値: {firstBanana.Value}"); // 出力: 5
        var lastBanana = list.FindLast(kvp => kvp.Key == "Banana");
        Console.WriteLine($"FindLastで取得したBananaの値: {lastBanana.Value}"); // 出力: 7
    }
}

Findで取得したBananaの値: 5
FindLastで取得したBananaの値: 7

このように、検索メソッドの特性を理解して使い分けることで、重複キーが存在する場合でも意図した要素を取得できます。

並べ替え

キーでの昇順・降順ソート

List<KeyValuePair<TKey, TValue>>の並べ替えは、Sortメソッドを使って簡単に行えます。

キーで昇順や降順にソートする場合は、Sortに比較用のラムダ式を渡すのが一般的です。

例えば、キーがstring型の場合、昇順ソートは以下のように記述します。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        // キーで昇順にソート
        list.Sort((x, y) => x.Key.CompareTo(y.Key));
        Console.WriteLine("キーで昇順ソート:");
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
        // キーで降順にソート
        list.Sort((x, y) => y.Key.CompareTo(x.Key));
        Console.WriteLine("キーで降順ソート:");
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

キーで昇順ソート:
Key: Apple, Value: 3
Key: Banana, Value: 5
Key: Cherry, Value: 2
キーで降順ソート:
Key: Cherry, Value: 2
Key: Banana, Value: 5
Key: Apple, Value: 3

CompareToメソッドは文字列の辞書順比較を行い、昇順はx.Key.CompareTo(y.Key)、降順はy.Key.CompareTo(x.Key)とします。

数値や他の型でも同様にCompareToを使えます。

値でのカスタムソート

値でソートしたい場合は、キーの比較と同様にSortメソッドに比較ロジックを渡します。

値の型によっては、単純な昇順・降順だけでなく、複雑な条件を加えたカスタムソートも可能です。

以下は、値で昇順にソートする例です。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        // 値で昇順にソート
        list.Sort((x, y) => x.Value.CompareTo(y.Value));
        Console.WriteLine("値で昇順ソート:");
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

値で昇順ソート:
Key: Cherry, Value: 2
Key: Apple, Value: 3
Key: Banana, Value: 5

Comparison<T>デリゲートの実装例

SortメソッドはComparison<T>デリゲートを受け取ります。

Comparison<T>は2つの要素を比較し、整数を返すメソッドの型です。

これを使ってカスタム比較ロジックを実装できます。

例えば、キーの長さでソートし、長さが同じ場合は値で昇順にソートする例を示します。

using System;
using System.Collections.Generic;
class Program
{
    // Comparisonデリゲートの実装
    static int CompareByKeyLengthThenValue(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
    {
        int lengthComparison = x.Key.Length.CompareTo(y.Key.Length);
        if (lengthComparison != 0)
        {
            return lengthComparison;
        }
        return x.Value.CompareTo(y.Value);
    }
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Fig", 7),
            new KeyValuePair<string, int>("Date", 2)
        };
        // Comparisonデリゲートを使ってソート
        list.Sort(CompareByKeyLengthThenValue);
        Console.WriteLine("キーの長さで昇順、同じ長さなら値で昇順ソート:");
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Length: {kvp.Key.Length}, Value: {kvp.Value}");
        }
    }
}

キーの長さで昇順、同じ長さなら値で昇順ソート:
Key: Fig, Length: 3, Value: 7
Key: Date, Length: 4, Value: 2
Key: Apple, Length: 5, Value: 3
Key: Banana, Length: 6, Value: 5

このように、Comparison<T>を使うと複雑なソート条件も柔軟に実装できます。

IComparerを用いた汎用化

IComparer<T>インターフェースを実装したクラスを作成し、Sortメソッドに渡すことで、再利用可能な比較ロジックを提供できます。

これにより、複数の場所で同じソート基準を使いたい場合に便利です。

以下は、キーの昇順ソートを行うIComparer実装例です。

using System;
using System.Collections.Generic;
// IComparerの実装
class KeyComparer : IComparer<KeyValuePair<string, int>>
{
    public int Compare(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
    {
        return x.Key.CompareTo(y.Key);
    }
}
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        // IComparerを使ってソート
        list.Sort(new KeyComparer());
        Console.WriteLine("IComparerでキー昇順ソート:");
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

IComparerでキー昇順ソート:
Key: Apple, Value: 3
Key: Banana, Value: 5
Key: Cherry, Value: 2

IComparerを使うメリットは、比較ロジックをクラスとして分離できるため、テストやメンテナンスがしやすくなることです。

また、複数のソート基準をクラスごとに用意して切り替えることも簡単です。

このように、List<KeyValuePair<TKey, TValue>>の並べ替えは、キーや値を基準にしたシンプルなソートから、複雑なカスタムソートまで柔軟に対応できます。

Comparison<T>やIComparerを活用して、用途に応じた最適なソート処理を実装してください。

グルーピングと集計

LINQ GroupByでカテゴリ別まとめ

List<KeyValuePair<TKey, TValue>>の要素をキーや値の条件でグルーピングし、カテゴリ別にまとめたい場合はLINQのGroupByメソッドが便利です。

GroupByは指定したキーに基づいて要素をグループ化し、グループごとに集計や処理を行えます。

以下は、キーの先頭文字でグルーピングし、各グループの要素数を集計する例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Avocado", 5),
            new KeyValuePair<string, int>("Banana", 2),
            new KeyValuePair<string, int>("Blueberry", 7),
            new KeyValuePair<string, int>("Cherry", 4)
        };
        // キーの先頭文字でグルーピング
        var grouped = list.GroupBy(kvp => kvp.Key[0]);
        foreach (var group in grouped)
        {
            Console.WriteLine($"グループ: {group.Key} (要素数: {group.Count()})");
            foreach (var kvp in group)
            {
                Console.WriteLine($"  Key: {kvp.Key}, Value: {kvp.Value}");
            }
        }
    }
}

グループ: A (要素数: 2)
  Key: Apple, Value: 3
  Key: Avocado, Value: 5
グループ: B (要素数: 2)
  Key: Banana, Value: 2
  Key: Blueberry, Value: 7
グループ: C (要素数: 1)
  Key: Cherry, Value: 4

この例では、キーの最初の文字をグループのキーとして、同じ文字で始まる要素をまとめています。

GroupByの戻り値はIEnumerable<IGrouping<TKey, TElement>>で、各グループはIGroupingとして扱えます。

グループごとに合計値や平均値などの集計も簡単に行えます。

// グループごとの値の合計を計算
var sumByGroup = list.GroupBy(kvp => kvp.Key[0])
                     .Select(g => new { Key = g.Key, Sum = g.Sum(kvp => kvp.Value) });
foreach (var item in sumByGroup)
{
    Console.WriteLine($"グループ: {item.Key}, 合計値: {item.Sum}");
}

グループ: A, 合計値: 8
グループ: B, 合計値: 9
グループ: C, 合計値: 4

ToDictionaryへの変換パターン

グルーピングや抽出した結果を、キーと値のペアとして辞書形式で扱いたい場合は、LINQのToDictionaryメソッドを使います。

ToDictionaryはシーケンスをDictionary<TKey, TValue>に変換し、キーの一意性を保証します。

例えば、先ほどのグループごとの合計値を辞書に変換する例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Avocado", 5),
            new KeyValuePair<string, int>("Banana", 2),
            new KeyValuePair<string, int>("Blueberry", 7),
            new KeyValuePair<string, int>("Cherry", 4)
        };
        // グループごとの合計値を辞書に変換
        var sumDict = list.GroupBy(kvp => kvp.Key[0])
                          .ToDictionary(
                              g => g.Key,
                              g => g.Sum(kvp => kvp.Value)
                          );
        foreach (var kvp in sumDict)
        {
            Console.WriteLine($"キー: {kvp.Key}, 合計値: {kvp.Value}");
        }
    }
}

キー: A, 合計値: 8
キー: B, 合計値: 9
キー: C, 合計値: 4

ToDictionaryを使う際は、キーが重複しないように注意が必要です。

重複がある場合は例外が発生します。

また、ToDictionaryの戻り値はDictionary<TKey, TValue>なので、検索や更新が高速に行えます。

集計結果の再利用テクニック

集計結果を再利用する場合、Dictionaryに変換しておくと効率的です。

例えば、複数回同じグループの合計値を参照する場合、毎回GroupByで集計するよりも辞書から直接取得したほうが高速です。

// 集計結果を辞書に保存
var sumDict = list.GroupBy(kvp => kvp.Key[0])
                  .ToDictionary(
                      g => g.Key,
                      g => g.Sum(kvp => kvp.Value)
                  );
// 何度も参照する場合
char[] keysToCheck = { 'A', 'B', 'D' };
foreach (var key in keysToCheck)
{
    if (sumDict.TryGetValue(key, out int total))
    {
        Console.WriteLine($"キー {key} の合計値: {total}");
    }
    else
    {
        Console.WriteLine($"キー {key} は存在しません");
    }
}

キー A の合計値: 8
キー B の合計値: 9
キー D は存在しません

このように、集計結果を辞書にしておくことで、存在チェックや値の取得が簡単かつ高速になります。

特に大規模データや頻繁に参照する場合に有効なテクニックです。

削除とクリア

Remove・RemoveAllの使い所

List<KeyValuePair<TKey, TValue>>から要素を削除する際には、RemoveとRemoveAllの使い分けが重要です。

Removeメソッド

指定した要素と完全に一致する最初の1件を削除します。

削除対象のKeyValuePairが明確に分かっている場合に使います。

戻り値は削除に成功したかどうかのboolです。

RemoveAllメソッド

指定した条件に合致するすべての要素を一括で削除します。

条件にマッチする複数の要素をまとめて削除したい場合に便利です。

戻り値は削除した要素数のintです。

例えば、キーが”Banana”の要素を削除する場合は以下のように使います。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Banana", 7),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        // RemoveAllでキーが"Banana"の要素をすべて削除
        int removedCount = list.RemoveAll(kvp => kvp.Key == "Banana");
        Console.WriteLine($"削除した要素数: {removedCount}");
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

削除した要素数: 2
Key: Apple, Value: 3
Key: Cherry, Value: 2

Removeは単一の要素を指定して削除するため、条件で削除したい場合はRemoveAllのほうが適しています。

条件付き削除時の注意点

条件付きで要素を削除する際には、以下の点に注意が必要です。

ループ中の削除は避ける

foreachループでコレクションを走査しながら要素を削除すると、InvalidOperationExceptionが発生します。

削除はRemoveAllやforループを使うか、削除対象を一旦別のリストに抽出してから行う方法が安全です。

削除条件の正確な指定

条件式が曖昧だと意図しない要素まで削除される可能性があります。

特にキーや値の比較は型や大文字・小文字の違いに注意してください。

削除後のインデックス変化

RemoveAllは内部で要素を詰めてリストを再構築するため、削除後のインデックスは変わります。

インデックスを使った処理がある場合は再取得が必要です。

削除対象が存在しない場合の挙動

削除対象がない場合、RemoveAllは0を返し、リストは変更されません。

これを利用して削除の有無を判定できます。

メモリ解放とClearの効果

List<T>のClearメソッドは、リスト内のすべての要素を削除し、Countを0にリセットします。

ただし、内部配列の容量Capacityはそのまま維持されます。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>(100);
        for (int i = 0; i < 50; i++)
        {
            list.Add(new KeyValuePair<string, int>($"Key{i}", i));
        }
        Console.WriteLine($"Clear前のCount: {list.Count}, Capacity: {list.Capacity}");
        list.Clear();
        Console.WriteLine($"Clear後のCount: {list.Count}, Capacity: {list.Capacity}");
    }
}

Clear前のCount: 50, Capacity: 100
Clear後のCount: 0, Capacity: 100

このように、Clearは要素を削除しても内部配列の容量は変わらず、メモリは解放されません。

これは、再度要素を追加する際のパフォーマンス向上のためです。

もし、メモリを完全に解放したい場合は、TrimExcessメソッドを使って容量を現在の要素数に合わせて縮小するか、新しいリストを作り直す方法があります。

// Clear後に容量を縮小
list.Clear();
list.TrimExcess();
Console.WriteLine($"TrimExcess後のCapacity: {list.Capacity}");

ただし、TrimExcessは容量を減らすために配列の再割り当てが発生し、パフォーマンスに影響を与える可能性があるため、頻繁に呼び出すのは避けるべきです。

このように、RemoveやRemoveAllは用途に応じて使い分け、条件付き削除時はループ中の削除を避けるなどの注意が必要です。

Clearは要素を一括削除しますが、メモリ解放は行わないため、必要に応じてTrimExcessを活用してください。

LINQと拡張メソッド活用

Selectで匿名型やタプルへ変換

List<KeyValuePair<TKey, TValue>>の要素を別の形に変換したい場合、LINQのSelectメソッドが便利です。

Selectは各要素に対して変換処理を行い、新しいシーケンスを生成します。

匿名型やタプルに変換することで、必要な情報だけを抽出したり、複数の値をまとめて扱いやすくしたりできます。

匿名型への変換例

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        // Selectで匿名型に変換(Keyの大文字化とValueの2倍)
        var transformed = list.Select(kvp => new
        {
            UpperKey = kvp.Key.ToUpper(),
            DoubleValue = kvp.Value * 2
        });
        foreach (var item in transformed)
        {
            Console.WriteLine($"Key: {item.UpperKey}, Value: {item.DoubleValue}");
        }
    }
}

Key: APPLE, Value: 6
Key: BANANA, Value: 10
Key: CHERRY, Value: 4

この例では、元のキーを大文字に変換し、値を2倍にした匿名型のシーケンスを作成しています。

匿名型は型名を明示しなくても使えるため、簡潔にデータを扱えます。

タプルへの変換例

C# 7.0以降では、タプルを使って複数の値をまとめることもできます。

var tupleList = list.Select(kvp => (Key: kvp.Key, Value: kvp.Value * 3));
foreach (var item in tupleList)
{
    Console.WriteLine($"Key: {item.Key}, Value: {item.Value}");
}

Key: Apple, Value: 9
Key: Banana, Value: 15
Key: Cherry, Value: 6

タプルは匿名型と似ていますが、名前付きフィールドを持ち、メソッドの戻り値や複数値の返却に便利です。

Any・Allでの条件判定

LINQのAnyとAllは、コレクション内の要素が条件を満たすかどうかを判定する拡張メソッドです。

Any

条件に合致する要素が1つでもあればtrueを返します。

空のコレクションに対してはfalseを返します。

All

すべての要素が条件を満たす場合にtrueを返します。

空のコレクションに対してはtrueを返します(論理的に「すべての要素が条件を満たす」は空集合に対して真となるため)。

例：キーに特定の文字が含まれるか判定

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        // キーに'A'が含まれる要素があるか
        bool hasA = list.Any(kvp => kvp.Key.Contains("A") || kvp.Key.Contains("a"));
        Console.WriteLine($"キーに'A'が含まれる要素があります: {hasA}");
        // すべての値が3以上か
        bool allAbove3 = list.All(kvp => kvp.Value >= 3);
        Console.WriteLine($"すべての値が3以上: {allAbove3}");
    }
}

キーに'A'が含まれる要素があります: True
すべての値が3以上: False

この例では、Anyでキーに’A’または’a’が含まれるかを判定し、Allで全要素の値が3以上かをチェックしています。

Aggregateによる集約処理

AggregateはLINQの強力な集約メソッドで、コレクションの要素を1つの値にまとめる際に使います。

累積的に処理を行い、合計や連結、複雑な集計も可能です。

例：値の合計を計算

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        // Aggregateで値の合計を計算
        int sum = list.Aggregate(0, (acc, kvp) => acc + kvp.Value);
        Console.WriteLine($"値の合計: {sum}");
    }
}

値の合計: 10

ここでは、初期値0からスタートし、各要素の値を累積して合計を求めています。

例：キーの連結

複数のキーをカンマ区切りの文字列にまとめる例です。

string concatenatedKeys = list.Aggregate("", (acc, kvp) =>
    string.IsNullOrEmpty(acc) ? kvp.Key : acc + ", " + kvp.Key);
Console.WriteLine($"連結したキー: {concatenatedKeys}");

連結したキー: Apple, Banana, Cherry

Aggregateは初期値と累積関数を指定することで、自由度の高い集約処理が可能です。

複雑な集計や変換を行いたい場合に活用してください。

パフォーマンス最適化

ループ処理とLINQの速度比較

List<KeyValuePair<TKey, TValue>>の要素を処理する際、従来のforループやforeachループとLINQを使った処理ではパフォーマンスに差が出ることがあります。

特に大量データを扱う場合は処理速度が重要になるため、使い分けが求められます。

ループ処理の特徴

forループ

インデックスを直接指定してアクセスするため、最も高速な処理が可能です。

特にListのようなインデックスアクセスが高速なコレクションで効果的です。

foreachループ

コレクションの列挙子を使うため、forに比べて若干オーバーヘッドがありますが、可読性が高く一般的に使われます。

LINQの特徴

LINQは内部で列挙子を使い、遅延評価や関数型スタイルの記述が可能です
しかし、メソッド呼び出しやデリゲートのオーバーヘッドがあり、単純なループに比べて処理速度は遅くなる傾向があります

実測例

以下は、100万件のKeyValuePair<string, int>の値を合計する処理の速度比較例です。

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>(10000000);
        for (int i = 0; i < 10000000; i++)
        {
            list.Add(new KeyValuePair<string, int>($"Key{i}", i));
        }
        var sw = new Stopwatch();
        // forループ
        sw.Start();
        long sumFor = 0;
        for (int i = 0; i < list.Count; i++)
        {
            sumFor += list[i].Value;
        }
        sw.Stop();
        Console.WriteLine($"forループ: {sw.ElapsedMilliseconds} ms, 合計: {sumFor}");
        // foreachループ
        sw.Restart();
        long sumForeach = 0;
        foreach (var kvp in list)
        {
            sumForeach += kvp.Value;
        }
        sw.Stop();
        Console.WriteLine($"foreachループ: {sw.ElapsedMilliseconds} ms, 合計: {sumForeach}");
        // LINQ Aggregate
        sw.Restart();
        long sumLinq = list.Aggregate(0L, (acc, kvp) => acc + kvp.Value);
        sw.Stop();
        Console.WriteLine($"LINQ Aggregate: {sw.ElapsedMilliseconds} ms, 合計: {sumLinq}");
    }
}

実行結果の例(環境によって異なります)：

forループ: 69 ms, 合計: 49999995000000
foreachループ: 74 ms, 合計: 49999995000000
LINQ Aggregate: 77 ms, 合計: 49999995000000

このように、単純な集計処理ではforループが最速で、foreachがわずかに遅く、LINQは最も遅くなる傾向があります。

パフォーマンスが重要な場面では、ループ処理を優先することが推奨されます。

Capacity事前確保の効果

List<T>は内部的に配列で要素を管理しており、要素数が増えると容量を自動的に拡張します。

この拡張は新しい配列を確保し、既存の要素をコピーするため、頻繁に発生するとパフォーマンスに悪影響を与えます。

事前に容量を指定するメリット

メモリ再確保の削減

予め必要な容量をListのコンストラクタで指定すると、拡張処理が減り、メモリコピーの回数が減ります。

処理速度の向上

再確保が減ることで、要素追加時のオーバーヘッドが減り、全体の処理速度が向上します。

実例

var listWithoutCapacity = new List<KeyValuePair<string, int>>();
var listWithCapacity = new List<KeyValuePair<string, int>>(1000000);
var sw = new Stopwatch();
// 容量指定なし
sw.Start();
for (int i = 0; i < 1000000; i++)
{
    listWithoutCapacity.Add(new KeyValuePair<string, int>($"Key{i}", i));
}
sw.Stop();
Console.WriteLine($"容量指定なし: {sw.ElapsedMilliseconds} ms");
// 容量指定あり
sw.Restart();
for (int i = 0; i < 1000000; i++)
{
    listWithCapacity.Add(new KeyValuePair<string, int>($"Key{i}", i));
}
sw.Stop();
Console.WriteLine($"容量指定あり: {sw.ElapsedMilliseconds} ms");

容量指定ありのほうが高速に処理できることが多いです。

特に大量データを扱う場合は、容量を適切に設定することがパフォーマンス最適化の基本となります。

構造体とボックス化の影響

KeyValuePair<TKey, TValue>は構造体structであり、値型として扱われます。

構造体はヒープではなくスタックに割り当てられるため、メモリ効率が良い場合がありますが、ボックス化(値型を参照型として扱う変換)が発生するとパフォーマンスに悪影響を及ぼします。

ボックス化とは

値型をobject型やインターフェース型に代入する際、値型のコピーがヒープ上に作成されることを指します
ボックス化はCPU負荷とメモリ使用量を増やし、ガベージコレクションの負担も増加します

KeyValuePairでの注意点

List<KeyValuePair<TKey, TValue>>をそのまま使う場合はボックス化は発生しません
しかし、IEnumerableや非ジェネリックなコレクションにキャストしたり、objectとして扱うとボックス化が発生します
LINQの一部メソッドや非ジェネリックAPIを使う際に注意が必要です

ボックス化を避ける例

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5)
        };
        // ボックス化が発生しない安全な列挙
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
        // 非ジェネリックIEnumerableにキャストするとボックス化が発生する可能性あり
        System.Collections.IEnumerable nonGeneric = list;
        foreach (object obj in nonGeneric)
        {
            // objはボックス化されたKeyValuePair
            Console.WriteLine(obj);
        }
    }
}

Key: Apple, Value: 3
Key: Banana, Value: 5
[Apple, 3]
[Banana, 5]

ボックス化はパフォーマンス低下の原因となるため、可能な限りジェネリックコレクションや型安全なAPIを使い、値型のまま処理することが望ましいです。

以上のポイントを踏まえ、List<KeyValuePair<TKey, TValue>>を扱う際は、処理内容に応じてループやLINQを使い分け、容量を事前に確保し、ボックス化を避ける設計を心がけることでパフォーマンスを最適化できます。

スレッドセーフ対策

lockでの排他制御

List<KeyValuePair<TKey, TValue>>はスレッドセーフではありません。

複数のスレッドから同時に読み書きすると、データの競合や不整合、例外が発生する可能性があります。

そのため、マルチスレッド環境で安全に操作するには排他制御が必要です。

C#ではlockキーワードを使って、特定のコードブロックを同時に1つのスレッドだけが実行できるように制御します。

これにより、リストへのアクセスを同期化し、競合状態を防ぎます。

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
class Program
{
    private static List<KeyValuePair<string, int>> sharedList = new List<KeyValuePair<string, int>>();
    private static readonly object lockObj = new object();
    static void Main()
    {
        var tasks = new List<Task>();
        // 複数スレッドでリストに要素を追加
        for (int i = 0; i < 5; i++)
        {
            int threadNum = i;
            tasks.Add(Task.Run(() =>
            {
                for (int j = 0; j < 10; j++)
                {
                    var kvp = new KeyValuePair<string, int>($"Thread{threadNum}_Item{j}", j);
                    lock (lockObj)
                    {
                        sharedList.Add(kvp);
                    }
                    Thread.Sleep(10); // 処理の遅延をシミュレート
                }
            }));
        }
        Task.WaitAll(tasks.ToArray());
        lock (lockObj)
        {
            Console.WriteLine($"合計要素数: {sharedList.Count}");
            foreach (var kvp in sharedList)
            {
                Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
            }
        }
    }
}

合計要素数: 50
Key: Thread0_Item0, Value: 0
Key: Thread0_Item1, Value: 1
...
Key: Thread4_Item9, Value: 9

この例では、複数のタスクが同時にsharedListにアクセスしますが、lockで排他制御しているため、データの競合や例外が発生しません。

lockObjという専用のオブジェクトを使って、Add操作や読み取り時の列挙を保護しています。

lock使用時のポイント

ロック対象は専用オブジェクトにする

lock(this)や共有リスト自体をロック対象にすると、外部からのロックと競合しやすくなります。

専用のreadonlyオブジェクトを用意しましょう。

ロック範囲は最小限に

処理時間が長いコードをロックすると、他のスレッドが待たされてパフォーマンスが低下します。

必要な操作だけをロック内に入れます。

デッドロックに注意

複数のロックを同時に取得する場合は、取得順序を統一し、デッドロックを防ぎます。

ConcurrentBag<KeyValuePair<,>>への置き換え

.NETのSystem.Collections.Concurrent名前空間には、スレッドセーフなコレクションが用意されています。

List<KeyValuePair<TKey, TValue>>の代わりにConcurrentBag<KeyValuePair<TKey, TValue>>を使うと、明示的なロックなしで複数スレッドから安全に追加や列挙が可能です。

ConcurrentBag<T>は順序を保証しませんが、スレッド間での高速な追加・取得に適しています。

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;
class Program
{
    private static ConcurrentBag<KeyValuePair<string, int>> concurrentBag = new ConcurrentBag<KeyValuePair<string, int>>();
    static void Main()
    {
        var tasks = new List<Task>();
        // 複数スレッドでConcurrentBagに要素を追加
        for (int i = 0; i < 5; i++)
        {
            int threadNum = i;
            tasks.Add(Task.Run(() =>
            {
                for (int j = 0; j < 10; j++)
                {
                    var kvp = new KeyValuePair<string, int>($"Thread{threadNum}_Item{j}", j);
                    concurrentBag.Add(kvp);
                }
            }));
        }
        Task.WaitAll(tasks.ToArray());
        Console.WriteLine($"合計要素数: {concurrentBag.Count}");
        foreach (var kvp in concurrentBag)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

合計要素数: 50
Key: Thread0_Item0, Value: 0
Key: Thread1_Item0, Value: 0
...
Key: Thread4_Item9, Value: 9

ConcurrentBagの特徴と注意点

スレッドセーフ

内部で排他制御を行っているため、複数スレッドからの同時アクセスが安全です。

順序は保証されない

要素の追加順序や列挙順序は保証されません。

順序が重要な場合は別のコレクションを検討してください。

高速な追加・取得

ロックフリーのアルゴリズムを使っているため、高速に動作します。

削除操作は限定的

ConcurrentBagは基本的に追加と列挙に特化しており、特定要素の削除はサポートしていません。

スレッドセーフなコレクション操作には、lockを使った明示的な排他制御と、ConcurrentBagのようなスレッドセーフコレクションの利用という2つのアプローチがあります。

用途やパフォーマンス要件に応じて適切な方法を選択してください。

イミュータブル設計への応用

ReadOnlyCollection<KeyValuePair<,>>の利用

イミュータブル(不変)設計は、データの変更を防ぎ、予期せぬ副作用やバグを減らすために有効な手法です。

List<KeyValuePair<TKey, TValue>>のような可変コレクションを外部に公開する際に、誤って変更されるのを防ぐためにReadOnlyCollection<KeyValuePair<TKey, TValue>>を利用することがよくあります。

ReadOnlyCollection<T>は、内部のコレクションをラップし、読み取り専用のインターフェースを提供します。

これにより、外部からの追加・削除・更新操作を禁止し、安全にデータを共有できます。

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
class Program
{
    static void Main()
    {
        var mutableList = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5)
        };
        // ListをReadOnlyCollectionでラップ
        ReadOnlyCollection<KeyValuePair<string, int>> readOnlyList = new ReadOnlyCollection<KeyValuePair<string, int>>(mutableList);
        Console.WriteLine("ReadOnlyCollectionの内容:");
        foreach (var kvp in readOnlyList)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
        // readOnlyList.Add(...) はコンパイルエラーで追加不可
        // readOnlyList[0] = new KeyValuePair<string, int>("Cherry", 7); も不可
        // 元のリストは変更可能
        mutableList.Add(new KeyValuePair<string, int>("Cherry", 7));
        Console.WriteLine("\n元のリストに要素を追加後のReadOnlyCollectionの内容:");
        foreach (var kvp in readOnlyList)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

ReadOnlyCollectionの内容:
Key: Apple, Value: 3
Key: Banana, Value: 5
元のリストに要素を追加後のReadOnlyCollectionの内容:
Key: Apple, Value: 3
Key: Banana, Value: 5
Key: Cherry, Value: 7

この例では、ReadOnlyCollectionは元のリストをラップしているため、元のリストが変更されるとReadOnlyCollectionの内容も変わります。

ただし、ReadOnlyCollection自体からは変更操作ができません。

これにより、外部に対しては読み取り専用のビューを提供しつつ、内部では柔軟に更新可能な設計が可能です。

イミュータブル設計のポイント

外部に公開する際はReadOnlyCollectionやIReadOnlyList<T>でラップし、変更を防ぐ
内部での変更は元のリストで行い、必要に応じて新しいReadOnlyCollectionを作成します
完全な不変性を求める場合は、元のリスト自体を変更しない設計や、新しいコレクションを返す方法を検討します

Record型での代替実装

C# 9.0以降で導入されたrecord型は、イミュータブルなデータ構造を簡単に実装できる機能です。

KeyValuePair<TKey, TValue>は構造体で不変ですが、recordを使うことでより柔軟にイミュータブルなキーと値のペアを表現できます。

Record型の基本例

using System;
using System.Collections.Generic;
public record KeyValueRecord<TKey, TValue>(TKey Key, TValue Value);
class Program
{
    static void Main()
    {
        var list = new List<KeyValueRecord<string, int>>()
        {
            new KeyValueRecord<string, int>("Apple", 3),
            new KeyValueRecord<string, int>("Banana", 5)
        };
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
        // イミュータブルなのでプロパティの変更は不可
        // kvp.Key = "Cherry"; // コンパイルエラー
        // 変更したい場合はwith式で新しいインスタンスを作成
        var modified = list[0] with { Value = 10 };
        Console.WriteLine($"\n変更後: Key: {modified.Key}, Value: {modified.Value}");
    }
}

Key: Apple, Value: 3
Key: Banana, Value: 5
変更後: Key: Apple, Value: 10

recordは以下の特徴を持ちます。

イミュータブルなプロパティ

コンストラクタで初期化した後は変更不可(initアクセサを使う場合は初期化時のみ変更可能)。

値の比較が容易

EqualsやGetHashCodeが自動生成され、値の等価性を簡単に比較できます。

with式によるコピーと変更

既存のインスタンスを元に一部のプロパティだけ変更した新しいインスタンスを作成可能です。

Record型を使うメリット

イミュータブルなデータを簡潔に表現できます
変更不可のため、スレッドセーフな設計に適しています
KeyValuePairよりも拡張性が高く、必要に応じてメソッドや追加プロパティを持たせられます

注意点

recordはクラスベースなので、構造体のKeyValuePairに比べてヒープ割り当てが発生しやすい
パフォーマンスが重要な場面では、構造体のKeyValuePairのほうが有利な場合があります

イミュータブル設計を意識する場合、ReadOnlyCollection<KeyValuePair<,>>で読み取り専用のビューを提供したり、record型でイミュータブルなペアを定義したりする方法があります。

用途やパフォーマンス要件に応じて適切な手法を選択してください。

実践シナリオ別サンプル

JSONパース後の順序保持

JSONデータをパースしてキーと値のペアを扱う場合、順序を保持したいことがあります。

Dictionaryはキーの順序を保証しないため、順序を保ちたい場合はList<KeyValuePair<string, object>>のようなリストで管理するのが有効です。

以下は、Newtonsoft.Json(Json.NET)を使ってJSONをパースし、順序を保ったままList<KeyValuePair<string, object>>に格納する例です。

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
class Program
{
    static void Main()
    {
        string json = @"{
            ""firstName"": ""John"",
            ""lastName"": ""Doe"",
            ""age"": 30,
            ""isEmployed"": true
        }";
        // JObjectでパース
        JObject jObject = JObject.Parse(json);
        // JObjectのプロパティを順序通りにList<KeyValuePair>に変換
        var list = new List<KeyValuePair<string, object>>();
        foreach (var prop in jObject.Properties())
        {
            list.Add(new KeyValuePair<string, object>(prop.Name, prop.Value));
        }
        // 順序を保ったまま表示
        foreach (var kvp in list)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

Key: firstName, Value: John
Key: lastName, Value: Doe
Key: age, Value: 30
Key: isEmployed, Value: True

この例では、JObject.Properties()がJSONのキーの順序を保持しているため、List<KeyValuePair<string, object>>に順序通りに格納できます。

これにより、JSONの元の順序を尊重した処理や表示が可能です。

設定ファイル読み込みと表示順管理

設定ファイル(例えばINIやYAML、JSONなど)を読み込んで、ユーザーに表示する際に元の記述順を保ちたい場合があります。

List<KeyValuePair<string, string>>を使うと、読み込み順を保持しつつキーと値を管理できます。

以下は、簡単な設定ファイルの読み込み例です。

ここではファイルの各行を「キー=値」の形式で読み込み、順序を保ったままリストに格納します。

using System;
using System.Collections.Generic;
using System.IO;
class Program
{
    static void Main()
    {
        string[] lines = {
            "username=alice",
            "theme=dark",
            "language=ja",
            "autosave=true"
        };
        var settings = new List<KeyValuePair<string, string>>();
        foreach (var line in lines)
        {
            if (string.IsNullOrWhiteSpace(line) || !line.Contains("="))
                continue;
            var parts = line.Split(new[] { '=' }, 2);
            string key = parts[0].Trim();
            string value = parts[1].Trim();
            settings.Add(new KeyValuePair<string, string>(key, value));
        }
        // 順序を保ったまま設定を表示
        foreach (var kvp in settings)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

Key: username, Value: alice
Key: theme, Value: dark
Key: language, Value: ja
Key: autosave, Value: true

この方法なら、設定ファイルの記述順をそのまま保持し、UIやログなどで順序通りに表示できます。

Dictionaryを使うと順序が保証されないため、順序が重要な場合はList<KeyValuePair<,>>が適しています。

UIデータバインディングでの利用

WPFやWinFormsなどのUIフレームワークで、キーと値のペアを順序通りに表示したい場合、List<KeyValuePair<TKey, TValue>>は便利です。

特にObservableCollection<KeyValuePair<TKey, TValue>>に変換すれば、UIの変更通知もサポートできます。

以下はWPFの簡単な例で、List<KeyValuePair<string, string>>をObservableCollectionに変換し、ListBoxにバインドして表示するイメージコードです。

// ViewModelの例
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
public class SettingsViewModel : INotifyPropertyChanged
{
    public ObservableCollection<KeyValuePair<string, string>> Settings { get; }
    public SettingsViewModel()
    {
        var list = new List<KeyValuePair<string, string>>()
        {
            new KeyValuePair<string, string>("Username", "alice"),
            new KeyValuePair<string, string>("Theme", "dark"),
            new KeyValuePair<string, string>("Language", "ja"),
            new KeyValuePair<string, string>("Autosave", "true")
        };
        Settings = new ObservableCollection<KeyValuePair<string, string>>(list);
    }
    public event PropertyChangedEventHandler PropertyChanged;
}

<!-- XAMLの例 -->
<ListBox ItemsSource="{Binding Settings}">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="{Binding Key}" Width="100"/>
                <TextBlock Text="{Binding Value}"/>
            </StackPanel>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

この構成により、Settingsコレクションの順序がUIに反映され、ユーザーに設定項目を順序通りに表示できます。

ObservableCollectionを使うことで、コレクションの変更がUIに自動的に反映されるため、動的な更新も簡単に実装可能です。

これらの実践例は、List<KeyValuePair<TKey, TValue>>の順序保持の特性を活かし、JSONパースや設定ファイルの読み込み、UI表示など多様なシナリオで役立ちます。

用途に応じて適切に活用してください。

エラー処理と例外ハンドリング

ArgumentNullExceptionの回避

List<KeyValuePair<TKey, TValue>>を操作する際に、引数として渡されるオブジェクトがnullの場合、ArgumentNullExceptionが発生することがあります。

特に、AddRangeやコンストラクタにnullを渡した場合や、LINQのメソッドでnullのコレクションを扱うときに注意が必要です。

例：AddRangeにnullを渡した場合

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var list = new List<KeyValuePair<string, int>>();
        List<KeyValuePair<string, int>> nullList = null;
        try
        {
            // nullを渡すとArgumentNullExceptionが発生
            list.AddRange(nullList);
        }
        catch (ArgumentNullException ex)
        {
            Console.WriteLine($"例外発生: {ex.Message}");
        }
    }
}

例外発生: 値は null にできません。 (パラメーター名: collection)

回避策

引数がnullでないことを事前にチェックする

メソッド呼び出し前にnullチェックを行い、nullの場合は空のコレクションを渡すか処理をスキップします。

if (nullList != null)
{
    list.AddRange(nullList);
}

メソッドの引数にnullが渡る可能性がある場合は、null許容を考慮した設計にする

例えば、呼び出し元でnullを空コレクションに変換するなど。

LINQメソッドの前にnullチェックを行う

LINQの拡張メソッドはnullのシーケンスに対して呼び出すと例外が発生します。

var source = GetCollection();
if (source != null)
{
    var filtered = source.Where(x => x.Key.StartsWith("A"));
}

キー未存在時の安全なアクセス方法

List<KeyValuePair<TKey, TValue>>はDictionaryのようにキーで直接アクセスできるインデクサを持ちません。

そのため、存在しないキーを検索して値を取得しようとすると、FindやLINQのFirstなどで例外や不正な値を扱うリスクがあります。

安全な検索例

Findを使う場合

var list = new List<KeyValuePair<string, int>>()
{
    new KeyValuePair<string, int>("Apple", 3),
    new KeyValuePair<string, int>("Banana", 5)
};
var result = list.Find(kvp => kvp.Key == "Cherry");
if (!result.Equals(default(KeyValuePair<string, int>)))
{
    Console.WriteLine($"値: {result.Value}");
}
else
{
    Console.WriteLine("キーが存在しません");
}

Findは該当なしの場合、default(KeyValuePair<TKey, TValue>)を返すため、これを判定して安全に処理します。

LINQのFirstOrDefaultを使う場合

using System.Linq;
var result = list.FirstOrDefault(kvp => kvp.Key == "Cherry");
if (!result.Equals(default(KeyValuePair<string, int>)))
{
    Console.WriteLine($"値: {result.Value}");
}
else
{
    Console.WriteLine("キーが存在しません");
}

TryGetValue的な拡張メソッドを自作する

List<KeyValuePair<TKey, TValue>>にはDictionaryのようなTryGetValueメソッドがないため、自作すると便利です。

public static bool TryGetValue<TKey, TValue>(this List<KeyValuePair<TKey, TValue>> list, TKey key, out TValue value)
{
    foreach (var kvp in list)
    {
        if (EqualityComparer<TKey>.Default.Equals(kvp.Key, key))
        {
            value = kvp.Value;
            return true;
        }
    }
    value = default;
    return false;
}

if (list.TryGetValue("Cherry", out int val))
{
    Console.WriteLine($"値: {val}");
}
else
{
    Console.WriteLine("キーが存在しません");
}

List<KeyValuePair<TKey, TValue>>でキーを検索する際は、存在しないキーに対する処理を必ず行います
FindやFirstOrDefaultの戻り値がdefaultかどうかを判定して安全に扱います
便利な拡張メソッドを作成して、TryGetValueのような使い方を実現するのもおすすめです

これらの対策を行うことで、例外の発生や不正な値の扱いを防ぎ、安全なコードを書くことができます。

型制約とジェネリックの理解

where TKey : notnullの意味

C#のジェネリック型パラメータに対してwhere TKey : notnullという型制約を付けることがあります。

これは、TKeyにnull許容型を禁止し、非null型のみを許可することを意味します。

背景と目的

Dictionary<TKey, TValue>やKeyValuePair<TKey, TValue>のようなコレクションでは、キーがnullであることは基本的に許されません。

nullキーは検索やハッシュ計算の際に問題を引き起こすためです。

C# 8.0以降のnullable reference types機能の導入により、参照型でもnull許容か非許容かを型システムで区別できるようになりました。

where TKey : notnullはこの機能を活用し、コンパイル時にnullを許容する型を排除します。

具体例

public class MyDictionary<TKey, TValue> where TKey : notnull
{
    private Dictionary<TKey, TValue> internalDict = new Dictionary<TKey, TValue>();
    public void Add(TKey key, TValue value)
    {
        internalDict.Add(key, value);
    }
}

このように宣言すると、TKeyにstringやintなどの非null型は指定できますが、string?やNullable<int>のようなnull許容型はコンパイルエラーになります。

var dict1 = new MyDictionary<string, int>(); // OK
var dict2 = new MyDictionary<string?, int>(); // コンパイルエラー
var dict3 = new MyDictionary<int?, int>(); // コンパイルエラー

メリット

安全性の向上

nullキーによるランタイムエラーを防止できます。

明示的な設計意図の表現

キーは必ず非nullであることを型制約で示せます。

コードの可読性向上

利用者に対してnullを許容しないことを明確に伝えられます。

Nullableキー使用時のリスク

Nullable型やnull許容参照型をキーとして使う場合、いくつかのリスクや問題が発生します。

ハッシュコード計算の問題

DictionaryやKeyValuePairはキーのハッシュコードを使って高速検索を行います。

nullキーの場合、GetHashCode()を呼び出すとNullReferenceExceptionが発生する可能性があります。

string? nullableKey = null;
int hash = nullableKey.GetHashCode(); // NullReferenceExceptionの可能性あり

等価比較の不整合

nullキーと非nullキーの比較は特別扱いが必要です。

Equalsメソッドでnullを正しく判定しないと、検索や削除が正しく動作しません。

コレクションの動作不良

nullキーを許容するコレクションは特殊な実装が必要です。

標準のDictionary<TKey, TValue>はnullキーを許容しません。

List<KeyValuePair<TKey, TValue>>ではnullキーを格納できますが、検索や比較時に注意が必要です。

バグや例外の原因

nullキーを扱うコードは、nullチェックを怠ると例外や不正な動作を引き起こしやすく、バグの温床になります。

対策例

where TKey : notnull制約を使う

コンパイル時にnull許容型を排除します。

nullチェックを徹底する

キーがnullでないことを明示的に確認してから処理します。

Nullable型をキーに使わない設計

可能な限りnullをキーにしない設計を心がける。

カスタム比較器の実装

nullを許容する場合は、IEqualityComparer<TKey>を実装してnullを適切に扱います。

class NullableStringComparer : IEqualityComparer<string?>
{
    public bool Equals(string? x, string? y)
    {
        return string.Equals(x, y, StringComparison.OrdinalIgnoreCase);
    }
    public int GetHashCode(string? obj)
    {
        return obj?.ToLowerInvariant().GetHashCode() ?? 0;
    }
}

where TKey : notnullはジェネリック型の安全性を高める重要な制約であり、nullキーの使用は多くのリスクを伴います。

キーの型設計やコレクションの使い方を見直し、nullを避けるか適切に扱うことが健全なコード作成につながります。

ユニットテスト視点

期待順序の検証パターン

List<KeyValuePair<TKey, TValue>>を使う場合、順序が重要な要素となることが多いため、ユニットテストでは期待される順序通りに要素が格納・処理されているかの検証が欠かせません。

順序検証の基本的な方法

期待値のリストを用意する

テスト対象の処理で生成されるリストと同じ順序・内容のList<KeyValuePair<TKey, TValue>>を用意します。

要素数の比較

実際のリストと期待リストのCountが一致しているかを確認します。

各要素のキーと値を順番に比較

インデックスを使って、実際のリストの各要素のKeyとValueが期待値と一致するかを検証します。

サンプルコード(NUnitを想定)

using NUnit.Framework;
using System.Collections.Generic;
[TestFixture]
public class KeyValuePairListTests
{
    [Test]
    public void TestListOrderAndContent()
    {
        // テスト対象のリスト(例)
        var actualList = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        // 期待値リスト
        var expectedList = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Cherry", 2)
        };
        Assert.AreEqual(expectedList.Count, actualList.Count, "要素数が一致しません");
        for (int i = 0; i < expectedList.Count; i++)
        {
            Assert.AreEqual(expectedList[i].Key, actualList[i].Key, $"キーが一致しません。インデックス: {i}");
            Assert.AreEqual(expectedList[i].Value, actualList[i].Value, $"値が一致しません。インデックス: {i}");
        }
    }
}

このように、順序と内容の両方を厳密に検証することで、処理の正確性を担保できます。

順序を無視した検証が必要な場合

場合によっては順序を気にせず、要素の存在だけを検証したいこともあります。

その場合は、CollectionAssert.AreEquivalentやLINQのExceptを使って比較しますが、List<KeyValuePair<,>>の順序保持が重要なケースでは上記のような順序検証が推奨されます。

テストデータ生成ヘルパ実装

ユニットテストで繰り返し使うテストデータを毎回手動で作成すると冗長になり、保守性が低下します。

そこで、テストデータ生成用のヘルパーメソッドやクラスを実装して、簡潔かつ再利用可能なテストコードを書くことが望ましいです。

シンプルなテストデータ生成メソッド例

using System.Collections.Generic;
public static class TestDataHelper
{
    public static List<KeyValuePair<string, int>> CreateSampleList()
    {
        return new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Banana", 5),
            new KeyValuePair<string, int>("Cherry", 2)
        };
    }
    public static List<KeyValuePair<string, int>> CreateListWithDuplicates()
    {
        return new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("Apple", 3),
            new KeyValuePair<string, int>("Apple", 4),
            new KeyValuePair<string, int>("Banana", 5)
        };
    }
}

テストコードでの利用例

[Test]
public void TestUsingHelperData()
{
    var testList = TestDataHelper.CreateSampleList();
    Assert.AreEqual(3, testList.Count);
    Assert.AreEqual("Banana", testList[1].Key);
    Assert.AreEqual(5, testList[1].Value);
}

複雑なデータ生成の工夫

パラメータ化

メソッドにパラメータを渡して、異なるパターンのデータを生成できるようにします。

ビルダーパターン

複雑なテストデータを段階的に構築するためのビルダークラスを作成します。

外部ファイルからの読み込み

JSONやCSVなどのファイルからテストデータを読み込むことで、大量かつ多様なデータを管理しやすくします。

テストデータ生成ヘルパーを活用することで、テストコードの可読性と保守性が向上し、テストの信頼性も高まります。

特にList<KeyValuePair<,>>のような順序と内容が重要なコレクションでは、期待値の明確化と再利用可能なデータ生成が効果的です。

リファクタリングと可読性向上

メソッドチェーンの整理

LINQや拡張メソッドを活用すると、List<KeyValuePair<TKey, TValue>>の操作をメソッドチェーンで記述することが多くなります。

メソッドチェーンはコードを簡潔に書ける反面、長く複雑になると可読性が低下し、保守が難しくなることがあります。

そこで、メソッドチェーンの整理によって可読性を向上させる工夫が重要です。

改善ポイント

適切な改行とインデント

長いチェーンは改行してインデントを揃えることで、処理の流れが見やすくなります。

中間変数の活用

複雑な処理を複数のステップに分割し、中間結果を変数に格納することで、各処理の意味を明確にできます。

意味のあるメソッド名の抽出

複雑な処理をメソッドに切り出し、名前を付けることで意図が伝わりやすくなります。

例：整理前のメソッドチェーン

var result = list.Where(kvp => kvp.Value > 10)
                 .OrderBy(kvp => kvp.Key)
                 .Select(kvp => kvp.Key.ToUpper())
                 .Distinct()
                 .ToList();

例：整理後のコード

var filtered = FilterByValueGreaterThan(list, 10);
var ordered = OrderByKey(filtered);
var upperKeys = ConvertKeysToUpper(ordered);
var distinctKeys = GetDistinctKeys(upperKeys);
var result = distinctKeys.ToList();
...
List<KeyValuePair<string, int>> FilterByValueGreaterThan(List<KeyValuePair<string, int>> source, int threshold)
{
    return source.Where(kvp => kvp.Value > threshold).ToList();
}
IOrderedEnumerable<KeyValuePair<string, int>> OrderByKey(List<KeyValuePair<string, int>> source)
{
    return source.OrderBy(kvp => kvp.Key);
}
IEnumerable<string> ConvertKeysToUpper(IEnumerable<KeyValuePair<string, int>> source)
{
    return source.Select(kvp => kvp.Key.ToUpper());
}
IEnumerable<string> GetDistinctKeys(IEnumerable<string> keys)
{
    return keys.Distinct();
}

このように処理を分割すると、各ステップの役割が明確になり、テストやデバッグも容易になります。

ジェネリック再利用による重複削減

List<KeyValuePair<TKey, TValue>>を扱うコードでは、キーや値の型が異なる場合でも似たような処理が繰り返されることがあります。

こうした重複コードは、ジェネリックメソッドやクラスを活用して再利用性を高めることで削減できます。

ジェネリックメソッドの例

using System;
using System.Collections.Generic;
using System.Linq;
public static class KeyValuePairUtils
{
    // 指定した値の閾値以上の要素をフィルタリングする汎用メソッド
    public static List<KeyValuePair<TKey, TValue>> FilterByValueThreshold<TKey, TValue>(
        List<KeyValuePair<TKey, TValue>> list,
        TValue threshold,
        Func<TValue, TValue, bool> comparer)
    {
        return list.Where(kvp => comparer(kvp.Value, threshold)).ToList();
    }
}

利用例

var intList = new List<KeyValuePair<string, int>>()
{
    new KeyValuePair<string, int>("A", 5),
    new KeyValuePair<string, int>("B", 15),
    new KeyValuePair<string, int>("C", 10)
};
var filtered = KeyValuePairUtils.FilterByValueThreshold(intList, 10, (value, threshold) => value >= threshold);
foreach (var kvp in filtered)
{
    Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
}

Key: B, Value: 15
Key: C, Value: 10

ジェネリッククラスの例

public class KeyValuePairProcessor<TKey, TValue>
{
    private List<KeyValuePair<TKey, TValue>> _list;
    public KeyValuePairProcessor(List<KeyValuePair<TKey, TValue>> list)
    {
        _list = list;
    }
    public List<KeyValuePair<TKey, TValue>> Filter(Func<KeyValuePair<TKey, TValue>, bool> predicate)
    {
        return _list.Where(predicate).ToList();
    }
    public List<TKey> GetKeys()
    {
        return _list.Select(kvp => kvp.Key).ToList();
    }
    // 他の共通処理も追加可能
}

利用例

var processor = new KeyValuePairProcessor<string, int>(intList);
var filteredList = processor.Filter(kvp => kvp.Value > 7);
var keys = processor.GetKeys();
Console.WriteLine("Filtered keys:");
foreach (var key in keys)
{
    Console.WriteLine(key);
}

ジェネリックを活用することで、型に依存しない汎用的な処理をまとめられ、コードの重複を減らしつつ保守性と拡張性を向上させられます。

特にKeyValuePair<TKey, TValue>のような汎用的なデータ構造を扱う場合は、積極的にジェネリック設計を取り入れることが効果的です。

まとめ

この記事では、C#のList<KeyValuePair<TKey, TValue>>を活用するための基本から応用まで幅広く解説しました。

順序保持のメリットや生成・初期化方法、要素の追加・更新、検索・抽出、並べ替え、グルーピング、削除、LINQ活用、パフォーマンス最適化、スレッドセーフ対策、イミュータブル設計、実践シナリオ、エラー処理、型制約、ユニットテスト、リファクタリングまで、効率的かつ安全に扱うためのポイントを具体例とともに紹介しています。

これにより、List<KeyValuePair>の特性を理解し、実務での活用や保守性の高いコード作成に役立てられます。