LINQ

[C#] LINQを使ったディクショナリ操作の方法

2025-04-15更新日: 2025-04-15

LINQを使ってC#のディクショナリを操作する方法は、ディクショナリのキーや値をフィルタリング、変換、並べ替えする際に非常に便利です。

例えば、Whereメソッドを使用して特定の条件に一致するキーと値のペアをフィルタリングできます。

また、Selectメソッドを使ってディクショナリの値を変換したり、OrderByを用いてキーや値で並べ替えることも可能です。

これにより、ディクショナリのデータを効率的に操作し、必要な情報を簡単に抽出できます。

目次から探す

LINQとディクショナリの基本

C#におけるLINQ(Language Integrated Query)は、データソースに対してクエリを実行するための強力な機能を提供します。

ディクショナリ(Dictionary)は、キーと値のペアを格納するためのコレクションで、キーを使って迅速に値を検索することができます。

LINQを使用することで、ディクショナリ内のデータを簡単にフィルタリング、変換、並べ替え、集計することが可能です。

この記事では、LINQを用いたディクショナリ操作の基本的な方法を解説し、実際のコード例を通じてその利便性を紹介します。

LINQを活用することで、ディクショナリの操作がより直感的かつ効率的になります。

LINQを使ったディクショナリのフィルタリング

ディクショナリのフィルタリングは、特定の条件に基づいてキーや値を選択するための重要な操作です。

LINQを使用することで、ディクショナリ内のデータを簡単にフィルタリングすることができます。

ここでは、Whereメソッドを使ったフィルタリングの方法を詳しく見ていきます。

Whereメソッドの使い方

Whereメソッドは、指定した条件に一致する要素をフィルタリングするために使用されます。

ディクショナリに対してWhereメソッドを適用することで、条件に合致するキーと値のペアを抽出できます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // 90点以上のスコアを持つエントリをフィルタリング
        var highScores = scores.Where(entry => entry.Value >= 90);
        // フィルタリング結果を表示
        foreach (var entry in highScores)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
    }
}

Bob: 92
David: 91

この例では、Whereメソッドを使用して、スコアが90点以上のエントリをフィルタリングしています。

条件に基づくキーのフィルタリング

キーに基づいてディクショナリをフィルタリングすることも可能です。

以下の例では、キーが特定の文字列で始まるエントリをフィルタリングしています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // "A"で始まるキーを持つエントリをフィルタリング
        var aNames = scores.Where(entry => entry.Key.StartsWith("A"));
        // フィルタリング結果を表示
        foreach (var entry in aNames)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
    }
}

Alice: 85

この例では、キーが”A”で始まるエントリをフィルタリングしています。

条件に基づく値のフィルタリング

値に基づいてフィルタリングする場合も、Whereメソッドを使用します。

以下の例では、特定の範囲内のスコアを持つエントリをフィルタリングしています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // スコアが80以上90未満のエントリをフィルタリング
        var midScores = scores.Where(entry => entry.Value >= 80 && entry.Value < 90);
        // フィルタリング結果を表示
        foreach (var entry in midScores)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
    }
}

Alice: 85

この例では、スコアが80以上90未満のエントリをフィルタリングしています。

LINQを使うことで、ディクショナリのフィルタリングが非常に簡単かつ直感的に行えます。

ディクショナリの変換と投影

ディクショナリのデータを別の形式に変換したり、特定の情報を抽出するために、LINQのSelectメソッドを活用することができます。

ここでは、ディクショナリのキーと値の変換や、匿名型を使った投影について解説します。

Selectメソッドの活用

Selectメソッドは、コレクションの各要素を変換するために使用されます。

ディクショナリに対してSelectを適用することで、キーと値のペアを別の形式に変換することが可能です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // 各エントリを文字列に変換
        var scoreStrings = scores.Select(entry => $"{entry.Key}のスコアは{entry.Value}点です");
        // 変換結果を表示
        foreach (var scoreString in scoreStrings)
        {
            Console.WriteLine(scoreString);
        }
    }
}

Aliceのスコアは85点です
Bobのスコアは92点です
Charlieのスコアは78点です
Davidのスコアは91点です

この例では、ディクショナリの各エントリを文字列に変換しています。

ディクショナリのキーと値の変換

ディクショナリのキーと値を別の形式に変換することも可能です。

以下の例では、キーを大文字に変換し、値を文字列に変換しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // キーを大文字に、値を文字列に変換
        var transformedScores = scores.Select(entry => new KeyValuePair<string, string>(entry.Key.ToUpper(), entry.Value.ToString()));
        // 変換結果を表示
        foreach (var entry in transformedScores)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
    }
}

ALICE: 85
BOB: 92
CHARLIE: 78
DAVID: 91

この例では、キーを大文字に変換し、値を文字列に変換しています。

匿名型を使った投影

匿名型を使うことで、ディクショナリのデータを特定の形式に投影することができます。

以下の例では、キーと値を持つ匿名型を作成しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // 匿名型を使って投影
        var projectedScores = scores.Select(entry => new { Name = entry.Key, Score = entry.Value });
        // 投影結果を表示
        foreach (var entry in projectedScores)
        {
            Console.WriteLine($"名前: {entry.Name}, スコア: {entry.Score}");
        }
    }
}

名前: Alice, スコア: 85
名前: Bob, スコア: 92
名前: Charlie, スコア: 78
名前: David, スコア: 91

この例では、ディクショナリのデータを匿名型に投影し、名前とスコアを持つオブジェクトを作成しています。

匿名型を使うことで、必要な情報だけを抽出し、柔軟にデータを扱うことができます。

ディクショナリの並べ替え

ディクショナリのデータを特定の順序で並べ替えることは、データの分析や表示において重要です。

LINQを使用することで、ディクショナリのキーや値に基づいて簡単に並べ替えを行うことができます。

ここでは、OrderByとOrderByDescendingメソッドを使った並べ替えの方法を解説します。

OrderByとOrderByDescendingの使い方

OrderByメソッドは、指定したキーに基づいて要素を昇順に並べ替えます。

一方、OrderByDescendingメソッドは、降順に並べ替えます。

これらのメソッドを使用することで、ディクショナリのデータを柔軟に並べ替えることができます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // スコアを昇順に並べ替え
        var orderedScores = scores.OrderBy(entry => entry.Value);
        // 並べ替え結果を表示
        Console.WriteLine("スコアを昇順に並べ替え:");
        foreach (var entry in orderedScores)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
        // スコアを降順に並べ替え
        var descendingScores = scores.OrderByDescending(entry => entry.Value);
        // 並べ替え結果を表示
        Console.WriteLine("\nスコアを降順に並べ替え:");
        foreach (var entry in descendingScores)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
    }
}

スコアを昇順に並べ替え:
Charlie: 78
Alice: 85
David: 91
Bob: 92
スコアを降順に並べ替え:
Bob: 92
David: 91
Alice: 85
Charlie: 78

この例では、OrderByを使ってスコアを昇順に、OrderByDescendingを使ってスコアを降順に並べ替えています。

キーによる並べ替え

ディクショナリのキーに基づいて並べ替えることも可能です。

以下の例では、キーをアルファベット順に並べ替えています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // キーをアルファベット順に並べ替え
        var orderedByKey = scores.OrderBy(entry => entry.Key);
        // 並べ替え結果を表示
        Console.WriteLine("キーをアルファベット順に並べ替え:");
        foreach (var entry in orderedByKey)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
    }
}

キーをアルファベット順に並べ替え:
Alice: 85
Bob: 92
Charlie: 78
David: 91

この例では、キーをアルファベット順に並べ替えています。

値による並べ替え

値に基づいてディクショナリを並べ替えることもできます。

以下の例では、値を昇順に並べ替えています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // 値を昇順に並べ替え
        var orderedByValue = scores.OrderBy(entry => entry.Value);
        // 並べ替え結果を表示
        Console.WriteLine("値を昇順に並べ替え:");
        foreach (var entry in orderedByValue)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
    }
}

値を昇順に並べ替え:
Charlie: 78
Alice: 85
David: 91
Bob: 92

この例では、値を昇順に並べ替えています。

LINQを使うことで、ディクショナリの並べ替えが非常に簡単に行えます。

ディクショナリの集計操作

ディクショナリのデータを集計することで、データの分析や統計情報の取得が可能になります。

LINQを使用することで、ディクショナリの要素数を取得したり、数値の合計や平均を計算したり、データをグループ化することができます。

ここでは、Countメソッド、SumやAverageメソッド、GroupByメソッドを使った集計操作について解説します。

Countメソッドで要素数を取得

Countメソッドは、ディクショナリの要素数を取得するために使用されます。

ディクショナリ全体の要素数を取得するだけでなく、特定の条件に一致する要素数を取得することも可能です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // ディクショナリの要素数を取得
        int totalCount = scores.Count();
        Console.WriteLine($"ディクショナリの要素数: {totalCount}");
        // スコアが80以上の要素数を取得
        int highScoreCount = scores.Count(entry => entry.Value >= 80);
        Console.WriteLine($"スコアが80以上の要素数: {highScoreCount}");
    }
}

ディクショナリの要素数: 4
スコアが80以上の要素数: 3

この例では、ディクショナリ全体の要素数と、スコアが80以上の要素数を取得しています。

SumやAverageを使った数値の集計

Sumメソッドは、数値の合計を計算するために使用されます。

また、Averageメソッドを使うことで、数値の平均を計算することができます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // スコアの合計を計算
        int totalScore = scores.Sum(entry => entry.Value);
        Console.WriteLine($"スコアの合計: {totalScore}");
        // スコアの平均を計算
        double averageScore = scores.Average(entry => entry.Value);
        Console.WriteLine($"スコアの平均: {averageScore:F2}");
    }
}

スコアの合計: 346
スコアの平均: 86.50

この例では、スコアの合計と平均を計算しています。

GroupByによるグループ化

GroupByメソッドを使用することで、ディクショナリのデータを特定の条件に基づいてグループ化することができます。

以下の例では、スコアを10点刻みでグループ化しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // スコアを10点刻みでグループ化
        var groupedScores = scores.GroupBy(entry => entry.Value / 10);
        // グループ化結果を表示
        foreach (var group in groupedScores)
        {
            Console.WriteLine($"スコア範囲: {group.Key * 10} - {group.Key * 10 + 9}");
            foreach (var entry in group)
            {
                Console.WriteLine($"  {entry.Key}: {entry.Value}");
            }
        }
    }
}

スコア範囲: 70 - 79
  Charlie: 78
スコア範囲: 80 - 89
  Alice: 85
スコア範囲: 90 - 99
  Bob: 92
  David: 91

この例では、スコアを10点刻みでグループ化し、各グループの内容を表示しています。

GroupByを使うことで、データを特定の基準で分類し、分析を行うことができます。

応用例

LINQを使用することで、ディクショナリの操作をさらに高度に行うことができます。

ここでは、複数条件でのフィルタリング、ディクショナリの結合操作、部分更新、そしてディクショナリからリストへの変換について解説します。

複数条件でのフィルタリング

複数の条件を組み合わせてディクショナリをフィルタリングすることが可能です。

以下の例では、スコアが80以上かつ名前が”B”で始まるエントリをフィルタリングしています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // 複数条件でフィルタリング
        var filteredScores = scores.Where(entry => entry.Value >= 80 && entry.Key.StartsWith("B"));
        // フィルタリング結果を表示
        foreach (var entry in filteredScores)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
    }
}

Bob: 92

この例では、スコアが80以上で名前が”B”で始まるエントリをフィルタリングしています。

ディクショナリの結合操作

複数のディクショナリを結合することも可能です。

以下の例では、2つのディクショナリを結合し、重複するキーの値を合計しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // 2つのサンプルディクショナリを作成
        Dictionary<string, int> scores1 = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 }
        };
        Dictionary<string, int> scores2 = new Dictionary<string, int>
        {
            { "Charlie", 78 },
            { "Bob", 8 }
        };
        // ディクショナリを結合し、重複するキーの値を合計
        var combinedScores = scores1.Concat(scores2)
                                    .GroupBy(entry => entry.Key)
                                    .ToDictionary(group => group.Key, group => group.Sum(entry => entry.Value));
        // 結合結果を表示
        foreach (var entry in combinedScores)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
    }
}

Alice: 85
Bob: 100
Charlie: 78

この例では、Bobのスコアが2つのディクショナリで合計されています。

ディクショナリの部分更新

ディクショナリの特定の要素を更新することも可能です。

以下の例では、スコアが80未満のエントリのスコアを10点加算しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // スコアが80未満のエントリを更新
        var updatedScores = scores.ToDictionary(entry => entry.Key, entry => entry.Value < 80 ? entry.Value + 10 : entry.Value);
        // 更新結果を表示
        foreach (var entry in updatedScores)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
    }
}

Alice: 85
Bob: 92
Charlie: 88
David: 91

この例では、Charlieのスコアが10点加算されています。

ディクショナリからリストへの変換

ディクショナリのデータをリストに変換することもできます。

以下の例では、ディクショナリのキーをリストに変換しています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        // サンプルのディクショナリを作成
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
            { "Alice", 85 },
            { "Bob", 92 },
            { "Charlie", 78 },
            { "David", 91 }
        };
        // キーをリストに変換
        List<string> names = scores.Keys.ToList();
        // リストの内容を表示
        Console.WriteLine("名前のリスト:");
        foreach (var name in names)
        {
            Console.WriteLine(name);
        }
    }
}

名前のリスト:
Alice
Bob
Charlie
David

この例では、ディクショナリのキーをリストに変換しています。

LINQを使うことで、ディクショナリのデータを柔軟に操作し、さまざまな形式に変換することが可能です。

まとめ

この記事では、C#のLINQを用いたディクショナリ操作の基本から応用までを詳しく解説しました。

LINQを活用することで、ディクショナリのフィルタリング、変換、並べ替え、集計といった操作が簡潔に行えることがわかります。

これを機に、実際のプロジェクトでLINQを活用し、コードの効率化と可読性の向上を目指してみてはいかがでしょうか。