比較のためのラムダ式とデリゲート

1. はじめに

例えば、学生のリストがあって、一度は年齢で、次は苗字で、その次は平均点で（しかも全試験合格者だけ）ソートしたいとする。こういう「一回きり」の比較ごとにIComparer<T>を実装した新しいクラスを書くと、プロジェクトがすぐに小さいコンパレータクラスだらけのゴミ箱になっちゃう。これ、めっちゃ面倒だし、コードも読みにくくなるよね。

こういう時、C#はもっとスマートな方法を用意してる。比較ロジックをSortメソッドに直接渡せるんだ。わざわざクラスを作らなくていい！

そのために必要なのがデリゲートと、そのコンパクトな兄弟であるラムダ式だよ。

デリゲートって何？

ラムダに行く前に、デリゲートって何かを整理しよう。簡単に言うと、デリゲートはメソッドへの参照を持つ型なんだ。ちょっと哲学っぽい？こう考えてみて：

やることリストがあって、その中には「手順」や「レシピ」みたいなものがある。デリゲートは、そういう「レシピ」（メソッド）への参照を保存できる特別な変数みたいなもの。で、やりたい時にそのデリゲート変数を呼び出すと、参照してるメソッドが実行されるってわけ。

C#では、デリゲートはコールバック（後でメソッドを呼ぶ、イベントの反応とか）、イベント処理（ボタン押しなどのアクションへの反応）、そしてメソッドを他のメソッドの引数として渡す（つまり、メソッドが別のメソッドを呼べるようにする）ために使われる。今回のソートもまさにそれ！

List<T>.Sort()メソッドにはいくつかバージョンがあって、その一つがComparison<T>っていう特別なデリゲートを受け取るんだ。

2. Comparison<T>デリゲート

Comparison<T>って何？

Comparison<T>は.NETに組み込まれてるデリゲートで、同じ型Tの2つのオブジェクトを比較するために作られてる。その「レシピ」はこう：2つのT型オブジェクト（ここではxとyとしよう）を受け取って、整数（int）を返す。

• 負の数（例：-1）ならxがyより「小さい」
• ゼロ（0）ならxとyは「等しい」
• 正の数（例：1）ならxがyより「大きい」

このルールはIComparable.CompareToやIComparer.Compareと同じ。つまり、ロジックは同じだけど、今度は「メソッド変数」として渡せるってこと。クラスを作る必要なし！

例を見てみよう。学生クラスに戻るよ。例えば、Studentクラスがあるとする：

public class Student
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
    public double AverageGrade { get; set; }

    public Student(string firstName, string lastName, int age, double averageGrade)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
        AverageGrade = averageGrade;
    }

    public void PrintInfo()
    {
        Console.WriteLine($"学生: {FirstName} {LastName}, 年齢: {Age}, 点数: {AverageGrade:F2}");
    }
}

じゃあ、デリゲートを使って学生リストを年齢順にソートしたい場合、Comparison<Student>のシグネチャに合う静的メソッドを書けばOK：

public class Program
{
    // Comparison<Student>デリゲートのシグネチャに合うメソッド
    // 2人の学生を年齢で比較する
    public static int CompareStudentsByAge(Student student1, Student student2)
    {
        // 数値のCompareToを使う
        // -1, 0, 1を返す
        return student1.Age.CompareTo(student2.Age);
    }

    public static void Main(string[] args)
    {
        List<Student> students = new List<Student>
        {
            new Student("イワン", "ペトロフ", 20, 4.5),
            new Student("マリア", "シドロワ", 22, 4.8),
            new Student("アレクセイ", "イワノフ", 19, 3.9),
            new Student("エレナ", "コズロワ", 20, 4.2) // 同じ年齢の学生2人
        };

        Console.WriteLine("--- ソート前の学生リスト ---");        
        foreach (var s in students)
            s.PrintInfo();

        Console.WriteLine("--- 年齢で学生をソート（デリゲート使用） ---");
        students.Sort(CompareStudentsByAge); //CompareStudentsByAgeメソッドを渡す

        foreach (var s in students)
            s.PrintInfo();
    }
}

コード解説：

1. 静的メソッドCompareStudentsByAgeを作った。2人の学生を受け取り、intを返す。Comparison<Student>の契約通り。
2. Mainで学生リストを作成。
3. students.Sort(CompareStudentsByAge);を呼ぶ時、CompareStudentsByAge()をすぐ実行するんじゃなくて、参照を渡してるだけ。List<T>.Sort()が必要なだけ何度も呼び出してくれる。これは、誰かに配送先の住所だけ渡して、トラック全部を一気に送るんじゃなくて、必要な時に送るのと同じ感じ。

このやり方は、毎回小さいコンパレータクラスを作るよりずっと便利。でも、もっと簡単にできる！

3. ラムダ式の登場！

CompareStudentsByAgeみたいなメソッドを書くのも、比較ロジックがシンプルで1～2回しか使わないなら、ちょっと面倒。そんな時のためにC#にはラムダ式（lambda expressions）があるんだ。

ラムダ式って何？ざっくり言うと、匿名メソッド。俺はよく「ホームレスメソッド」って冗談で呼ぶけど（笑）。必要な場所に、短いコード（メソッド）をその場で書ける。マニュアルじゃなくて、付箋に手順を書いて直接貼るイメージ。

ラムダ式のメインの記号は=>（「矢印」や「～へ」って読む）。パラメータとメソッド本体を分けるやつね。

ラムダ式の基本構文

例えば、デリゲート（メソッド参照）をSort()に渡す場合：

public static int CompareStudentsByAge(Student student1, Student student2)
{
   return student1.Age.CompareTo(student2.Age);
}

students.Sort(CompareStudentsByAge); //CompareStudentsByAgeメソッドを渡す

これ、もっと短く書けるよ：

//匿名メソッドをそのまま渡す
students.Sort( (Student student1, Student student2) => student1.Age.CompareTo(student2.Age) );

ここでは、メソッド名の代わりに大事な2つだけ書いてる：

• パラメータ: (Student student1, Student student2)
• メソッド本体: student1.Age.CompareTo(student2.Age)

このコンパクトな書き方がラムダ式：(パラメータ) => 式

どう動くの？

C#のコンパイラは、ラムダ式を見つけると、本物のメソッドを自動生成してくれる。

例えば、こんなコードがあったら：

students.Sort( (s1, s2) => s2.AverageGrade.CompareTo(s1.AverageGrade) );

コンパイル結果はだいたいこんな感じになる：

public static int CompareStudents_Lambda123(Student s1, Student s2)
{
   return s2.AverageGrade.CompareTo(s1.AverageGrade);
}

students.Sort( CompareStudents_Lambda123 );

4. ソート例とラムダ式

じゃあ、さっきの学生の例をラムダ式で書き直してみよう：

public class Program
{
    public static void Main(string[] args)
    {
        List<Student> students = new List<Student>
        {
            new Student("イワン", "ペトロフ", 20, 4.5),
            new Student("マリア", "シドロワ", 22, 4.8),
            new Student("アレクセイ", "イワノフ", 19, 3.9),
            new Student("エレナ", "コズロワ", 20, 4.2)
        };

        Console.WriteLine("--- ソート前の学生リスト ---");        
        foreach (var s in students)
            s.PrintInfo();

        // 比較ロジックをここに直接書く
        Console.WriteLine("--- 年齢で学生をソート（ラムダ式使用） ---");
        students.Sort((student1, student2) => student1.Age.CompareTo(student2.Age));

        foreach (var s in students)
            s.PrintInfo();

        // 降順ソートは-1を掛けるだけ
        Console.WriteLine("\n--- 平均点で学生を降順ソート ---");
        // s2.CompareTo(s1)にするだけ
        students.Sort((s1, s2) => s2.AverageGrade.CompareTo(s1.AverageGrade));

        foreach (var s in students)
            s.PrintInfo();
    }
}

ここで何が起きてる？

1. students.Sort((student1, student2) => student1.Age.CompareTo(student2.Age));
   • student1とstudent2は、Sortが匿名メソッドに渡すパラメータ（Comparison<T>のxとyと同じ）。
   • =>はラムダ演算子。
   • student1.Age.CompareTo(student2.Age)がラムダ式の本体。これが返り値になる。
2. 平均点で降順にソートするには、CompareToの引数を逆にするだけ。これで順序が逆転する。

なぜ便利？

• コンパクト: ちょっとした比較ロジックごとにメソッドやクラスを作らなくていい。
• 読みやすい: 比較ロジックがSort()のすぐそばにあるから、コードが分かりやすい。特にシンプルな場合は最高。
• 柔軟: ソート条件をその場で簡単に変えられる。

5. デリゲートとラムダは最強コンビ

「ラムダ式ってデリゲートと同じ？それとも違う？」って疑問が出るかも。

実は、ラムダ式はシンタックスシュガー（syntax sugar）で、デリゲートや式ツリー（Expression Tree、これはまた今度）を作るための書き方。コンパイラはラムダ式を見ると、勝手に適切なデリゲートのインスタンスに変換してくれる。今回の場合、List<T>.Sort()がComparison<T>を期待してるから、(student1, student2) => student1.Age.CompareTo(student2.Age)をComparison<Student>にしてくれる。

つまり、ラムダ式で超短いコードが書けて、デリゲートがその「入れ物」として動く。2つはセットで使うものなんだ！

どれを使う？

• IComparable<T>: 型に自然で明らかなソート方法がある時に使う。例えば商品なら品番順とか。これは「デフォルトの順序」を決めるインターフェース。
• IComparer<T>: 何度も使う・再利用したい比較ロジックが必要な時や、メインクラスを「汚したくない」時、または複数のソート方法がある時に使う。例えば、価格順と名前順で別々のIComparerを作って、プログラムの色んな所で使い分ける。
• デリゲート（Comparison<T>）とラムダ式: 一回きり・その場限り（ad-hoc）のソートに最適。比較ロジックがシンプルで、クラス化するほどじゃない時に一番キレイな方法。フィルタ（Find, FindAll）や検索（FindIndex）など、他のメソッドにロジックを渡す時にも超便利。

someList.Sort()

someList.Sort(new MyComparer())

someList.Sort((x, y) => x.Prop.CompareTo(y.Prop))

6. 実践とこれから

ラムダ式は、単なる「ソート用のシンタックスシュガー」じゃない。現代C#コードでめっちゃ使われてる強力なツールだよ。これから何度も出会うはず：

• LINQ（Language Integrated Query）で: ラムダ式の一番有名な使い道。LINQはSQLっぽいクエリをコレクションに書けて、フィルタやソート、データ変換の条件をラムダで指定する。LINQはもうすぐ勉強するけど、ラムダのおかげで超パワフル＆便利になるのが分かるはず。
• イベント処理で: 例えばUIのボタン押しなど、何かが起きた時に「何をするか」を短く書ける。
• 非同期プログラミングで: 並列で実行したいタスクの定義に使う。
• .NETの色んなAPIで: 標準ライブラリの多くのメソッドがデリゲート（つまりラムダ式）を受け取って、柔軟なロジックを追加できる。

つまり、ラムダ式をマスターすれば、ソートだけじゃなく、現代C#コードやライブラリの理解が一気に進む。どんな面接でも評価されるし、どんなプロジェクトでも役立つスキルだよ！

7. よくあるミスとポイント

比較用のデリゲートやラムダ式を使う時、気をつけたいポイントがいくつかある：

比較結果が間違ってる: CompareToや比較ロジックは、必ず負の数・ゼロ・正の数を返すこと。うっかりtrueやfalseを返すと、ソートが変になったりエラーになる。Sortは数値の結果を期待してる。なぜなら、単に「等しい」だけじゃなく、「どっちが大きいか」も知りたいから。

null値の扱い: コレクションの要素がnullになる可能性がある場合、nullオブジェクトでメソッドを呼ぶと（例：student1.Age.CompareTo(...)でstudent1がnull）、NullReferenceExceptionになる。こういう時は、比較ロジックでnullを明示的に処理しよう。一般的には、nullは「どんな値よりも小さい」とみなす。両方nullなら等しい。片方だけnullなら、nullが「小さい」。

// nullを考慮したラムダ式の例
students.Sort((s1, s2) => {
    if (s1 == null && s2 == null) return 0;
    if (s1 == null) return -1; // nullは最小
    if (s2 == null) return 1;  // 非nullはnullより大きい
    return s1.Age.CompareTo(s2.Age); // 両方非nullなら比較
});

実際のプロジェクトでは、コレクションにnullが入ってることはあまりないけど、頭の片隅に置いておこう！

パフォーマンス: ラムダ式は超便利だけど、めちゃくちゃ大きいコレクションや「激アツ」なループの中で使いまくると、最適化されたIComparerクラスよりちょっとだけ遅くなることも。でも、普段使いなら気にしなくてOK。読みやすさとシンプルさのメリットの方が圧倒的に大きい。

複雑な比較チェーン: 苗字→名前のように複数条件でソートしたい時、ラムダ式ならネストして書ける。ifを10個並べるよりずっと楽！コツは、まず最初の比較結果（lastNameComparison != 0）を見て、0じゃなければそれを返し、0なら次の条件に進むこと。

ラムダ式とデリゲートは、C#の基礎であり、もっと柔軟で関数型っぽいプログラミングへの扉。これを理解して使いこなせば、コードがずっとキレイで効率的、そして現代的になるよ。どんどん試して、すぐに「当たり前」に使えるようになろう！

2

タスク

C# SELF, レベル 30, レッスン 2

ロック未解除

ラムダ式を使った数値のソート

ラムダ式を使った数値のソート

オープン