【C#】ラムダ式完全ガイド｜クロージャ・Func/Action・式ツリー・静的ラムダ・メソッドグループ・パフォーマンスまで

// 式ラムダ（Expression Lambda）: 右辺が単一の式
Func<int, int>    square   = x => x * x;           // 引数1つ: 括弧省略可
Func<int, int, int> add    = (x, y) => x + y;      // 引数2つ以上: 括弧必須
Func<int>          getOne  = () => 1;               // 引数なし: () 必須
Action<string>     print   = s => Console.WriteLine(s);

Console.WriteLine(square(5));    // 25
Console.WriteLine(add(3, 4));    // 7

// ステートメントラムダ（Statement Lambda）: 右辺が複数文のブロック
Func<int, string> describe = n =>
{
    if (n > 0)  return "正の数";
    if (n < 0)  return "負の数";
    return "ゼロ";
};
Console.WriteLine(describe(-3));  // "負の数"

// 型を明示する場合（C# 10+: パラメーターに型注釈）
Func<int, int> doubleIt = (int x) => x * 2;   // 型を明示
Func<int, int> tripleIt = (int x) => { return x * 3; }; // 明示 + ブロック

// Action: 副作用だけ行う処理
Action<string>        log      = msg => Console.WriteLine($"[LOG] {msg}");
Action<string, int>   repeat   = (s, n) => { for (int i = 0; i < n; i++) Console.Write(s); };

log("起動完了");
repeat("* ", 5);   // * * * * *

// Func: 値を返す処理
Func<string, int>     length   = s => s.Length;
Func<int, int, bool>  isLarger = (a, b) => a > b;

Console.WriteLine(length("Hello"));      // 5
Console.WriteLine(isLarger(10, 3));      // True

// Predicate<T>: List<T>.Find などで使われる
Predicate<int> isEven = n => n % 2 == 0;
var numbers = new List<int> { 1, 2, 3, 4, 5 };
int firstEven = numbers.Find(isEven);    // 2

// Predicate<T> は Func<T, bool> に暗黙変換できない（別の型）
Func<int, bool> funcVersion = isEven.Invoke;  // Invoke 経由でラップ

// カスタムデリゲートが必要な場面: ref/out パラメーター
// Func<ref int, void> は書けない → クラスレベルでカスタムデリゲートを宣言して使う
//   ↓ クラス/名前空間レベルで宣言（メソッド内では宣言不可）
//   delegate void Transformer(ref int value);
//
// 使用例:
//   Transformer increment = (ref int x) => x++;
//   int val = 10;
//   increment(ref val);
//   Console.WriteLine(val);  // 11

// NG: ラムダ式でパラメーターを無視する場合（C# 9 以前）
// シグネチャが一致しないとコンパイルエラー
// EventHandler ev1 = () => Console.WriteLine("clicked"); // 引数が足りない

// OK: 匿名メソッドならパラメーターリストを丸ごと省略できる
// どんなシグネチャのデリゲートにも代入できる
EventHandler ev2 = delegate { Console.WriteLine("clicked"); };  // (sender, e) を無視

// EventHandler<T>、カスタムデリゲートでも同様に使える
button.Click   += delegate { DoSomething(); };
timer.Elapsed  += delegate { CheckStatus(); };

// C# 9+ のラムダ: _ でパラメーターを捨てられる
EventHandler ev3 = (_, _) => Console.WriteLine("clicked");   // 捨てパラメーター

// C# 9+: _ の改良
button.Click += (_, _) => DoSomething();   // ラムダ式でも対応可

// 現代的な推奨: C# 9 以降は _ 付きラムダが readable かつ推奨
// 匿名メソッドは C# 9+ ではほぼ使う理由がなくなった

// メソッドグループ: ラムダ不要でそのまま代入
Action<string>       print1  = Console.WriteLine;    // メソッドグループ
Action<string>       print2  = s => Console.WriteLine(s);  // 等価なラムダ式

Func<string, int>    len1    = s => s.Length;        // ラムダ式
// Func<string, int> len2 = s.Length は書けない（プロパティ）

// LINQ でのメソッドグループ変換
var words = new[] { "apple", "banana", "cherry" };
var lengths = words.Select(s => s.Length);             // ラムダ式
// string.Length はプロパティなのでメソッドグループ変換不可

// メソッドグループの利点: ラムダより簡潔・パフォーマンスが良い場合がある
var lines = new[] { "  hello  ", " world ", " c#  " };

// ラムダ: 毎回クロージャオブジェクトが作られる可能性
var trimmed1 = lines.Select(s => s.Trim());

// メソッドグループ: static メソッドならキャッシュされる（.NET 8+）
// string.Trim はインスタンスメソッドなので等価だが、
// static メソッドはコンパイラが最適化できる
Func<double, double> abs = Math.Abs;
double[] values = { -1.0, 2.5, -3.7 };
var positives = values.Select(Math.Abs);  // メソッドグループ（キャッシュ可能）

// イベント登録/解除でも使える
button.Click += HandleClick;   // メソッドグループ
button.Click -= HandleClick;   // 解除も可（ラムダ式だと解除できない！）

static void HandleClick(object? sender, EventArgs e)
    => Console.WriteLine("クリックされた");

// 書いたコード
int multiplier = 3;
Func<int, int> triple = x => x * multiplier;   // multiplier をキャプチャ

Console.WriteLine(triple(5));   // 15
multiplier = 10;                // キャプチャした変数を変更
Console.WriteLine(triple(5));   // 50 ← 変更が反映される！（参照キャプチャ）

// コンパイラが内部的に生成するコード（擬似コード）
// キャプチャ変数をフィールドに持つクラスが自動生成される
class <>c__DisplayClass
{
    public int multiplier;  // キャプチャされた変数
}
// ラムダ式本体はこのクラスのインスタンスメソッドになる
// → ヒープアロケーションが発生する（パフォーマンスに影響）

// キャプチャなし（外部変数を参照しない）の場合:
Func<int, int> square = x => x * x;
// → コンパイラがキャッシュできる（アロケーションなし）

// NG: for ループの変数キャプチャ（C# 5 以前の foreach でも同様の問題があった）
var actions = new List<Action>();
for (int i = 0; i < 3; i++)
{
    actions.Add(() => Console.WriteLine(i));  // i を参照キャプチャ
}
actions.ForEach(a => a());
// 出力: 3, 3, 3  ← 3つとも同じ i を参照しているため、ループ終了後の 3 を出力

// NG と思いきや: C# 5 以降の foreach は修正済み
var items = new[] { "A", "B", "C" };
var actions2 = new List<Action>();
foreach (var item in items)
{
    actions2.Add(() => Console.WriteLine(item));  // C# 5+ では安全
}
actions2.ForEach(a => a());
// 出力: A, B, C  ← foreach のイテレーション変数は各回で新しい変数

// for ループは今も要注意（foreach とは異なる）
// 対策1: ローカル変数にコピーしてキャプチャ
var actions3 = new List<Action>();
for (int i = 0; i < 3; i++)
{
    int captured = i;   // ループ内でコピーを作る
    actions3.Add(() => Console.WriteLine(captured));
}
actions3.ForEach(a => a());
// 出力: 0, 1, 2  ← 各ラムダが別の変数をキャプチャ

// 対策2: LINQ で構築（即値評価）
var printActions = Enumerable.Range(0, 3)
    .Select(i => (Action)(() => Console.WriteLine(i)))
    .ToList();
printActions.ForEach(a => a());
// 出力: 0, 1, 2

using System.Linq.Expressions;

// Func<T>: コンパイル済みの実行可能デリゲート
Func<int, bool> isEven1 = x => x % 2 == 0;
Console.WriteLine(isEven1(4));   // True（即座に実行）

// Expression<Func<T>>: ラムダ式の「構造」を表すデータ
Expression<Func<int, bool>> isEven2 = x => x % 2 == 0;
// → コードは実行されない。式ツリーとして保持される

// 式ツリーの中身を見る
Console.WriteLine(isEven2.Body);         // (x % 2) == 0
Console.WriteLine(isEven2.Parameters[0].Name); // x

// .Compile() でデリゲートに変換して実行できる
Func<int, bool> compiled = isEven2.Compile();
Console.WriteLine(compiled(4));   // True

// 式ツリーを構築・変換する例
// x => x.Name.StartsWith("A") を式ツリーとして作成
var param  = Expression.Parameter(typeof(string), "x");
var method = typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!;
var call   = Expression.Call(param, method, Expression.Constant("A"));
var lambda = Expression.Lambda<Func<string, bool>>(call, param);

Func<string, bool> startsWithA = lambda.Compile();
Console.WriteLine(startsWithA("Alice")); // True
Console.WriteLine(startsWithA("Bob"));   // False

// IEnumerable<T>: Func<T> を使い、メモリ上で実行
IEnumerable<string> names = new[] { "Alice", "Bob", "Charlie" };
var result1 = names.Where(n => n.StartsWith("A")); // ラムダ式が直接実行される
// → 全件メモリに読み込んでからフィルタ

// IQueryable<T>: Expression<Func<T>> を使い、SQL に変換
// （EF Core での例 - 実際には DbSet を使う）
IQueryable<string>? queryable = null;  // 擬似的な表現
// var result2 = queryable.Where(n => n.StartsWith("A"));
// → WHERE Name LIKE 'A%' という SQL が生成される！
// → DBサーバー側でフィルタリング（高効率）

// 注意: IQueryable に渡すラムダは式ツリーとして解釈される
// メモリ内の関数を渡すと式ツリーに変換できずエラーや非効率になる
Func<string, bool> funcFilter = n => n.StartsWith("A");
// queryable.Where(funcFilter);  // 式ツリーに変換できない → IEnumerable に落ちて全件取得

// 解決: 式ツリーとして定義する
Expression<Func<string, bool>> exprFilter = n => n.StartsWith("A");
// queryable.Where(exprFilter);  // SQL に変換される

// 通常のラムダ: キャプチャなしでも毎回デリゲートオブジェクトが作られる可能性
Func<int, int> normal = x => x * 2;

// static ラムダ（C# 9+）: キャプチャ不可 → アロケーションなし（コンパイラがキャッシュ）
Func<int, int> staticLambda = static x => x * 2;

// static ラムダ内で外部変数をキャプチャしようとするとコンパイルエラー
int factor = 3;
// Func<int, int> bad = static x => x * factor;  // CS8820: static ラムダではキャプチャ不可

// 定数は参照できる（値が固定のため問題なし）
const int MULTIPLIER = 3;
Func<int, int> good = static x => x * MULTIPLIER;   // OK: 定数は参照可

// LINQ でのパフォーマンス最適化
var numbers = Enumerable.Range(1, 1_000_000);

// 通常ラムダ: 毎回の呼び出しでデリゲートインスタンスが異なる可能性
var sum1 = numbers.Where(x => x % 2 == 0).Sum();

// static ラムダ: キャッシュされてアロケーション削減
var sum2 = numbers.Where(static x => x % 2 == 0).Sum();

// static キーワードはコンパイラへの意図の表明でもある:
// 「このラムダは外部状態に依存しない」
Console.WriteLine(sum1 == sum2);  // True

// C# 9 以前: var で受け取れない（型が決まらない）
// var f = x => x + 1;  // CS0815: ラムダ式を暗黙的型指定変数に代入できない

// C# 10+: var が使える（自然型推論）
var square   = (int x) => x * x;             // Func<int, int> と推論
var printMsg = (string s) => Console.WriteLine(s); // Action<string> と推論

Console.WriteLine(square(7));  // 49

// 戻り値の型注釈（C# 10+）
var abs = int (int x) => x < 0 ? -x : x;    // 戻り値型を明示
Console.WriteLine(abs(-5));   // 5

// ラムダに属性を付ける（C# 10+）
var divide = [return: MaybeNull]
    (int a, int b) => b == 0 ? (int?)null : a / b;

// メソッドグループの自然型（C# 10+）
var trim = string.IsNullOrWhiteSpace;  // Func<string?, bool> と推論
Console.WriteLine(trim("  "));         // True

// 注意: 自然型はオーバーロードが1つの場合のみ推論できる
// var parse = int.Parse;  // CS8917: オーバーロードが複数あるので推論不可
Func<string, int> parse = int.Parse;  // 型を明示すれば解決

// 再帰: ローカル関数は自分自身を直接呼べる
static int Fibonacci(int n)
{
    // ローカル関数で再帰（スタックトレースに "Fib" が出る）
    int Fib(int x) => x <= 1 ? x : Fib(x - 1) + Fib(x - 2);
    return Fib(n);
}

// イテレーター: ローカル関数内で yield return
static IEnumerable<int> GetEvenNumbers(int max)
{
    // 引数検証を先に行い、実際の列挙はローカル関数で
    if (max < 0) throw new ArgumentOutOfRangeException(nameof(max));

    return Impl(max);   // イテレーターの遅延評価を保つ

    static IEnumerable<int> Impl(int limit)
    {
        for (int i = 0; i <= limit; i += 2)
            yield return i;
    }
}

// デバッグ: ローカル関数は名前がスタックトレースに表示される
static async Task ProcessAsync()
{
    await Inner();  // スタックトレースに "Inner" と出る

    async Task Inner()
    {
        await Task.Delay(100);
        throw new InvalidOperationException("エラー");
    }
}

// ケース1: キャプチャなし（静的メソッドとして実装可能）
// → コンパイラがデリゲートをキャッシュ（同じインスタンスを再利用）
Func<int, int> f1 = x => x * 2;   // ヒープアロケーション: 初回1回のみ（キャッシュ）

// ケース2: インスタンスメンバーをキャプチャ（this キャプチャ）
// → デリゲートは毎回または1回（this が固定なのでキャッシュ可能な場合も）
class MyClass
{
    private int _value = 10;
    Func<int, int> f2 => x => x + _value;  // プロパティにすると毎回新インスタンス
    Func<int, int> _f2cached;
    Func<int, int> F2 => _f2cached ??= x => x + _value;  // キャッシュ
}

// ケース3: ローカル変数をキャプチャ
// → 毎回ヒープアロケーション（クロージャクラスのインスタンス生成）
int multiplier = 5;
Func<int, int> f3 = x => x * multiplier;  // ヒープアロケーション: 毎回

// ケース4: static ラムダ（C# 9+）
Func<int, int> f4 = static x => x * 2;   // キャプチャ禁止 → コンパイラがキャッシュ保証

// パフォーマンスが重要な場面のガイドライン:
// 1. 高頻度で呼ばれる LINQ/コールバックでは static ラムダを使う
// 2. キャプチャが必要なら変数をフィールドにしてラムダをキャッシュする
// 3. ローカル変数のキャプチャはホットパスで避ける

// 変換処理をラムダで組み合わせる（関数型スタイル）
static Func<T, TResult> Compose<T, TMiddle, TResult>(
    Func<T, TMiddle> first,
    Func<TMiddle, TResult> second)
    => x => second(first(x));

Func<string, string> trim       = static s => s.Trim();
Func<string, string> toUpper    = static s => s.ToUpper();
Func<string, bool>   isNotEmpty = static s => s.Length > 0;

var normalize = Compose(trim, toUpper);

var inputs = new[] { "  hello  ", " world ", "  ", "  c#  " };
var results = inputs
    .Where(isNotEmpty)           // 先に空文字を除外（static ラムダ）
    .Select(normalize)           // トリム + 大文字変換
    .Where(static s => s.Length > 0)  // 空文字（スペースのみ）を除外
    .ToArray();

Console.WriteLine(string.Join(", ", results));  // HELLO, WORLD, C#

// ラムダを返す: ファクトリーパターン
static Func<int, bool> CreateRangeChecker(int min, int max)
    => x => x >= min && x <= max;   // min, max をクロージャでキャプチャ

var isScore    = CreateRangeChecker(0, 100);
var isInniable = CreateRangeChecker(18, 65);

Console.WriteLine(isScore(85));     // True
Console.WriteLine(isInniable(17));  // False