csharp lambda完全ガイド：書き方・使いどころ・LINQでの実践例を初心者向けに解説

はじめに

C#を学び始めると、x => x * 2 や user => user.Age >= 20 のような書き方を目にすることがあります。これがC#のラムダ式です。

「csharp lambda」と検索する人の多くは、ラムダ式の書き方、=> の意味、Func や Action との関係、LINQでの使い方がよく分からずに調べているのではないでしょうか。

ラムダ式は、最初は記号が多く見えて難しく感じるかもしれません。しかし本質はとてもシンプルです。C#のラムダ式は、処理を短く書いて、変数に入れたり、メソッドの引数として渡したりするための記法です。

特にLINQではラムダ式が頻繁に使われます。たとえば、配列から偶数だけを取り出す処理は次のように書けます。

C#
int[] numbers = { 1, 2, 3, 4, 5, 6 };

var evenNumbers = numbers.Where(n => n % 2 == 0);

foreach (var number in evenNumbers)
{
    Console.WriteLine(number);
}

n => n % 2 == 0 の部分がラムダ式です。意味は「nを受け取り、nが偶数かどうかを判定する処理」です。

この記事では、csharp lambdaの基本構文から、デリゲート、Func、Action、Predicate、LINQでの実践例、よくあるエラー、読みやすく書くコツ、Expressionやstaticラムダといった発展的な内容まで、初心者にも分かるように順番に解説します。

1. csharp lambdaとは？初心者が最初に押さえるべき全体像

1-1. C#のラムダ式は「名前のない関数」を短く書く記法

C#のラムダ式は、ひと言でいうと「名前のない関数」を短く書くための記法です。Microsoft Learnでも、ラムダ式は匿名関数を作成するために使う構文として説明されています。

通常のメソッドは、次のように名前を付けて定義します。

C#
static int Double(int x)
{
    return x * 2;
}

このメソッドは、Double という名前を持っています。

一方、ラムダ式では同じような処理を次のように書けます。

C#
Func<int, int> doubleValue = x => x * 2;

この x => x * 2 がラムダ式です。Double というメソッド名を付けなくても、「xを受け取って、xの2倍を返す処理」を表現できます。

ラムダ式は、単独で存在するというよりも、次のような形で使われることが多いです。

C#
Func<int, int> square = x => x * x;

Console.WriteLine(square(5)); // 25

この例では、square という変数にラムダ式を代入しています。square(5) と呼び出すと、5 * 5 が計算されて 25 が返ります。

1-2. ラムダ式を使うとコードが読みやすくなる理由

ラムダ式を使うと、短い処理をその場で書けるようになります。

たとえば、数値リストから偶数だけを取り出す処理を、ラムダ式なしで書くと次のようになります。

C#
static bool IsEven(int n)
{
    return n % 2 == 0;
}

int[] numbers = { 1, 2, 3, 4, 5, 6 };

var evenNumbers = numbers.Where(IsEven);

もちろん、この書き方も正しいです。ただし、IsEven がその場でしか使われない短い処理であれば、わざわざメソッドとして定義するのは少し大げさです。

ラムダ式を使うと、次のように書けます。

C#
int[] numbers = { 1, 2, 3, 4, 5, 6 };

var evenNumbers = numbers.Where(n => n % 2 == 0);

「numbersの中から、nが偶数であるものを取り出す」という意図が1行で分かります。

ラムダ式が読みやすくなる主な理由は、処理の内容を使う場所の近くに書けるからです。特にLINQでは、「どの条件で絞るのか」「何を取り出すのか」「何で並び替えるのか」をラムダ式で直感的に表現できます。

1-3. 「csharp lambda」で検索する人が混同しやすいAWS Lambdaとの違い

「lambda」という言葉で混同しやすいものに、AWS Lambdaがあります。

C#のラムダ式は、C#言語の構文です。x => x * 2 のように、関数のような処理を短く書くために使います。

一方、AWS LambdaはAmazon Web Servicesが提供するクラウドサービスの一種です。AWS Lambdaは、サーバーを自分で管理せずにコードを実行するためのサーバーレス実行環境です。

つまり、両者はまったく別のものです。

C#のラムダ式:
C#のコード内で使う「名前のない関数」の書き方

AWS Lambda:
クラウド上でコードを実行するためのサービス

ただし、AWS Lambda上でC#のコードを動かすことはあります。そのため、AWS Lambdaの中でC#ラムダ式を書くことも可能です。しかし、「csharp lambda」と検索して => の書き方を知りたい場合は、基本的にはC#のラムダ式を学べば問題ありません。

1-4. ラムダ式・匿名メソッド・デリゲート・LINQの関係

ラムダ式を理解するには、周辺用語との関係を整理しておくと分かりやすくなります。

ラムダ式は、匿名関数を簡潔に書くための構文です。

匿名メソッドは、ラムダ式が登場する前からある「名前のないメソッド」を書く方法です。

C#
Func<int, int> square = delegate (int x)
{
    return x * x;
};

これをラムダ式で書くと、次のようになります。

C#
Func<int, int> square = x => x * x;

デリゲートは、メソッドやラムダ式を代入できる型です。Func<int, int> や Action<string> もデリゲートの一種です。

LINQは、配列やリストなどのコレクションを検索、抽出、変換、並び替え、集計するための機能です。LINQのメソッド構文では、条件や変換処理をラムダ式で渡すことが多いです。Microsoft Learnでも、LINQの作成時にラムダ式を使用できることが示されています。

関係をまとめると、次のようになります。

デリゲート:
処理を入れられる型

ラムダ式:
デリゲートに代入できる短い関数の書き方

匿名メソッド:
ラムダ式より古い、名前のないメソッドの書き方

LINQ:
ラムダ式をよく使う代表的な機能

2. C#ラムダ式の基本構文と読み方

2-1. ラムダ演算子「=>」の意味

C#のラムダ式では、=> という記号を使います。これはラムダ演算子、またはラムダ宣言演算子と呼ばれます。

基本形は次のとおりです。

C#
引数 => 処理

たとえば、次のラムダ式を見てみましょう。

C#
x => x * 2

これは、次のように読みます。

xを受け取って、x * 2 を返す

もう少し具体的に書くと、次のような通常メソッドに近い意味です。

C#
static int Double(int x)
{
    return x * 2;
}

=> の左側には入力、右側には処理を書きます。

C#
n => n > 10

これは「nを受け取って、nが10より大きいかどうかを返す」という意味です。

C#
name => name.ToUpper()

これは「nameを受け取って、大文字に変換して返す」という意味です。

2-2. 引数が1つの場合の書き方

引数が1つだけの場合、ラムダ式では引数のかっこを省略できます。

C#
Func<int, int> doubleValue = x => x * 2;

これは次のようにも書けます。

C#
Func<int, int> doubleValue = (x) => x * 2;

どちらも同じ意味です。

ただし、一般的には、引数が1つで型を明示しない場合は、かっこを省略して書くことが多いです。

C#
var names = new List<string> { "Alice", "Bob", "Charlie" };

var shortNames = names.Where(name => name.Length <= 3);

この例では、name => name.Length <= 3 がラムダ式です。「nameを受け取り、文字数が3以下かどうかを返す」という意味になります。

2-3. 引数が複数ある場合の書き方

引数が2つ以上ある場合は、かっこが必要です。

C#
Func<int, int, int> add = (x, y) => x + y;

Console.WriteLine(add(3, 5)); // 8

Func<int, int, int> は、「intを2つ受け取り、intを返す処理」を表します。

ラムダ式の部分は次のとおりです。

C#
(x, y) => x + y

これは「xとyを受け取り、x + y を返す」という意味です。

LINQでも、複数引数のラムダ式を使うことがあります。たとえば、Select では要素とインデックスを受け取れるオーバーロードがあります。

C#
var fruits = new List<string> { "Apple", "Banana", "Orange" };

var indexedFruits = fruits.Select((fruit, index) => $"{index}: {fruit}");

foreach (var item in indexedFruits)
{
    Console.WriteLine(item);
}

出力は次のようになります。

0: Apple
1: Banana
2: Orange

2-4. 引数がない場合の書き方

引数がないラムダ式では、空のかっこ () を使います。

C#
Action sayHello = () => Console.WriteLine("Hello!");

sayHello();

Action は、戻り値がない処理を表すデリゲートです。

現在時刻を返すラムダ式なら、次のように書けます。

C#
Func<DateTime> getNow = () => DateTime.Now;

Console.WriteLine(getNow());

() は「引数なし」を意味します。つまり、() => DateTime.Now は「何も受け取らず、現在時刻を返す処理」です。

2-5. 戻り値があるラムダ式の書き方

戻り値があるラムダ式は、右側に返したい値を表す式を書きます。

C#
Func<int, int> square = x => x * x;

int result = square(4);

Console.WriteLine(result); // 16

このような1行のラムダ式では、return を書きません。x * x の結果がそのまま戻り値になります。

文字列を返す例も見てみましょう。

C#
Func<string, string> greet = name => $"こんにちは、{name}さん";

Console.WriteLine(greet("田中"));

出力は次のようになります。

こんにちは、田中さん

条件判定のように bool を返すラムダ式もよく使います。

C#
Func<int, bool> isAdult = age => age >= 20;

Console.WriteLine(isAdult(18)); // False
Console.WriteLine(isAdult(25)); // True

2-6. 処理が複数行になるステートメントラムダの書き方

ラムダ式の処理が複数行になる場合は、 { } を使ってステートメントラムダとして書きます。

C#
Func<int, int> calculate = x =>
{
    int doubled = x * 2;
    int result = doubled + 10;
    return result;
};

Console.WriteLine(calculate(5)); // 20

複数行のラムダ式では、戻り値がある場合に return が必要です。

戻り値がない場合は、Action を使えます。

C#
Action<string> printMessage = message =>
{
    Console.WriteLine("メッセージを表示します");
    Console.WriteLine(message);
};

printMessage("ラムダ式の練習です");

ステートメントラムダは便利ですが、長くなりすぎると読みにくくなります。Microsoft Learnでも、ステートメントラムダの本体は任意の数のステートメントを含められるものの、実際には通常2つか3つ以下にすることが多いと説明されています。

3. ラムダ式を理解するための前提知識

3-1. デリゲートとは何か

デリゲートとは、メソッドを参照できる型です。もう少し初心者向けに言うと、「処理を変数のように扱うための型」です。

たとえば、次のようなメソッドがあるとします。

C#
static int Double(int x)
{
    return x * 2;
}

このメソッドを Func<int, int> 型の変数に代入できます。

C#
Func<int, int> operation = Double;

Console.WriteLine(operation(5)); // 10

ラムダ式も同じように代入できます。

C#
Func<int, int> operation = x => x * 2;

Console.WriteLine(operation(5)); // 10

つまり、デリゲート型があるから、ラムダ式を変数に入れたり、メソッドの引数として渡したりできます。

自分でデリゲート型を定義することもできます。

C#
delegate int Calculator(int x, int y);

Calculator add = (x, y) => x + y;

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

ただし、実務では Func、Action、Predicate を使うことが多いため、最初はこの3つを覚えるとよいでしょう。

3-2. Funcの使い方

Func は、戻り値がある処理を表すデリゲートです。

C#
Func<入力型, 戻り値の型>

引数が1つで戻り値がある場合は、次のように書きます。

C#
Func<int, int> square = x => x * x;

Console.WriteLine(square(5)); // 25

この場合、最初の int が引数の型、最後の int が戻り値の型です。

C#
Func<int, int>

これは「intを受け取り、intを返す処理」です。

引数が2つの場合は、次のようになります。

C#
Func<int, int, int> add = (x, y) => x + y;

Console.WriteLine(add(10, 20)); // 30

Func<int, int, int> は、「intを2つ受け取り、intを返す処理」です。Func では、最後の型が戻り値の型になります。

文字列を受け取って文字数を返す例です。

C#
Func<string, int> getLength = text => text.Length;

Console.WriteLine(getLength("CSharp")); // 6

3-3. Actionの使い方

Action は、戻り値がない処理を表すデリゲートです。

たとえば、文字列を受け取って表示するだけの処理は、戻り値がありません。

C#
Action<string> print = message => Console.WriteLine(message);

print("Hello Lambda");

引数がない場合は、次のように書きます。

C#
Action greet = () => Console.WriteLine("こんにちは");

greet();

引数が複数ある場合も使えます。

C#
Action<string, int> showUser = (name, age) =>
{
    Console.WriteLine($"{name}さんは{age}歳です");
};

showUser("佐藤", 30);

Action は、イベント処理、ログ出力、コールバックなどでよく使われます。

Func と Action の違いは、戻り値があるかどうかです。

Func:
戻り値がある

Action:
戻り値がない

3-4. Predicateの使い方

Predicate<T> は、ある値を受け取って bool を返すデリゲートです。

つまり、条件判定に使います。

C#
Predicate<int> isEven = n => n % 2 == 0;

Console.WriteLine(isEven(4)); // True
Console.WriteLine(isEven(5)); // False

Predicate<int> は、次の Func とほぼ同じような意味です。

C#
Func<int, bool> isEven = n => n % 2 == 0;

どちらも「intを受け取り、boolを返す処理」です。

Predicate<T> は、List<T>.Find や List<T>.RemoveAll などで使われます。

C#
var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

numbers.RemoveAll(n => n % 2 == 0);

Console.WriteLine(string.Join(", ", numbers)); // 1, 3, 5

この例では、偶数に該当する要素をリストから削除しています。

3-5. 型推論によりラムダ式が短く書ける仕組み

ラムダ式では、多くの場合、引数の型を書かなくてもコンパイラが推論してくれます。

たとえば、次のコードを見てください。

C#
Func<int, bool> isEven = n => n % 2 == 0;

n の型は書いていません。しかし、左側に Func<int, bool> と書かれているため、コンパイラは「nはintだ」と判断できます。

明示的に型を書くこともできます。

C#
Func<int, bool> isEven = (int n) => n % 2 == 0;

LINQでも型推論が働きます。

C#
var names = new List<string> { "Alice", "Bob", "Charlie" };

var result = names.Where(name => name.Length > 3);

names は List<string> なので、Where の中の name は string だと推論されます。そのため、name.Length と書けます。

型推論により、ラムダ式は短く読みやすく書けます。ただし、型が推論できない場面では、明示的に型を書く必要があります。

4. C#ラムダ式の具体的な書き方サンプル

4-1. 数値を計算するラムダ式

数値計算は、ラムダ式の基本を理解するのに向いています。

C#
Func<int, int> doubleValue = x => x * 2;

Console.WriteLine(doubleValue(10)); // 20

2つの数値を足す例です。

C#
Func<int, int, int> add = (x, y) => x + y;

Console.WriteLine(add(3, 7)); // 10

消費税込み価格を計算する例です。

C#
Func<decimal, decimal> addTax = price => price * 1.10m;

Console.WriteLine(addTax(1000m)); // 1100.00

decimal を使う場合、数値の後ろに m を付けます。金額計算では、double より decimal が使われることが多いです。

4-2. 文字列を加工するラムダ式

文字列を加工するラムダ式もよく使います。

C#
Func<string, string> toUpper = text => text.ToUpper();

Console.WriteLine(toUpper("csharp lambda")); // CSHARP LAMBDA

前後の空白を削除する例です。

C#
Func<string, string> trim = text => text.Trim();

Console.WriteLine(trim("  hello  ")); // hello

名前に敬称を付ける例です。

C#
Func<string, string> addSan = name => $"{name}さん";

Console.WriteLine(addSan("山田")); // 山田さん

複数行で少し複雑にすることもできます。

C#
Func<string, string> normalizeName = name =>
{
    string trimmed = name.Trim();
    string upper = trimmed.ToUpper();
    return upper;
};

Console.WriteLine(normalizeName("  taro  ")); // TARO

4-3. 条件判定を行うラムダ式

条件判定では、bool を返すラムダ式を使います。

C#
Func<int, bool> isEven = n => n % 2 == 0;

Console.WriteLine(isEven(8)); // True
Console.WriteLine(isEven(9)); // False

20歳以上かどうかを判定する例です。

C#
Func<int, bool> isAdult = age => age >= 20;

Console.WriteLine(isAdult(19)); // False
Console.WriteLine(isAdult(20)); // True

文字列が空でないかを判定する例です。

C#
Func<string, bool> hasValue = text => !string.IsNullOrWhiteSpace(text);

Console.WriteLine(hasValue("hello")); // True
Console.WriteLine(hasValue("   "));   // False

LINQの Where では、このような条件判定のラムダ式を頻繁に使います。

4-4. オブジェクトのプロパティを使うラムダ式

実務では、数値や文字列だけでなく、オブジェクトのプロパティを使うラムダ式がよく登場します。

次のような User クラスを考えます。

C#
public class User
{
    public string Name { get; set; } = "";
    public int Age { get; set; }
}

ユーザー一覧から20歳以上のユーザーだけを抽出します。

C#
var users = new List<User>
{
    new User { Name = "田中", Age = 18 },
    new User { Name = "佐藤", Age = 25 },
    new User { Name = "鈴木", Age = 30 }
};

var adults = users.Where(user => user.Age >= 20);

foreach (var user in adults)
{
    Console.WriteLine(user.Name);
}

user => user.Age >= 20 は、「userを受け取り、Ageが20以上かどうかを返す」という意味です。

名前だけを取り出す場合は、Select を使います。

C#
var names = users.Select(user => user.Name);

foreach (var name in names)
{
    Console.WriteLine(name);
}

このように、ラムダ式ではオブジェクトのプロパティにアクセスして、条件判定や変換を行えます。

4-5. 変数をキャプチャするラムダ式

ラムダ式は、外側の変数を使うことができます。これをキャプチャと呼びます。

C#
int threshold = 20;

Func<int, bool> isGreaterThanThreshold = x => x > threshold;

Console.WriteLine(isGreaterThanThreshold(25)); // True
Console.WriteLine(isGreaterThanThreshold(10)); // False

この例では、ラムダ式の外側で定義された threshold を、ラムダ式の中で使っています。

LINQでもよく使います。

C#
int minAge = 20;

var adults = users.Where(user => user.Age >= minAge);

minAge の値を変えると、判定条件も変わります。

C#
int minAge = 20;

Func<User, bool> filter = user => user.Age >= minAge;

minAge = 30;

var result = users.Where(filter);

このように、ラムダ式は変数そのものを参照するため、後から変数の値が変わると結果に影響する場合があります。便利な一方で、意図しない動作の原因にもなるため注意が必要です。

4-6. ラムダ式をメソッドの引数として渡す例

ラムダ式は、メソッドの引数として渡せます。これは非常に重要な使い方です。

たとえば、次のようなメソッドを作ります。

C#
static void PrintNumbers(IEnumerable<int> numbers, Func<int, bool> condition)
{
    foreach (var number in numbers)
    {
        if (condition(number))
        {
            Console.WriteLine(number);
        }
    }
}

このメソッドは、数値一覧と条件を受け取り、条件に合う数値だけを表示します。

使う側では、条件をラムダ式で渡せます。

C#
var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

PrintNumbers(numbers, n => n % 2 == 0);

奇数だけ表示したい場合は、ラムダ式を変えるだけです。

C#
PrintNumbers(numbers, n => n % 2 == 1);

10より大きい数だけ表示する場合も同じです。

C#
PrintNumbers(numbers, n => n > 10);

このように、処理の一部を外から渡せるようにすると、柔軟なメソッドを作れます。

5. ラムダ式はどこで使う？代表的な使いどころ

5-1. LINQでコレクションを検索・抽出する

C#ラムダ式の最も代表的な使いどころはLINQです。

Where を使うと、条件に合う要素だけを抽出できます。

C#
var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

var evenNumbers = numbers.Where(n => n % 2 == 0);

文字列リストから、A で始まるものだけを取り出す例です。

C#
var names = new List<string> { "Alice", "Bob", "Anna", "Tom" };

var aNames = names.Where(name => name.StartsWith("A"));

オブジェクト一覧から条件に合うものを探す例です。

C#
var activeUsers = users.Where(user => user.Age >= 20);

このように、LINQとラムダ式を組み合わせると、コレクション操作を短く分かりやすく書けます。

5-2. 並び替えやグループ化を簡潔に書く

ラムダ式は、並び替えにもよく使います。

C#
var orderedUsers = users.OrderBy(user => user.Age);

これは、Age の昇順でユーザーを並び替えます。

降順にする場合は、OrderByDescending を使います。

C#
var orderedUsers = users.OrderByDescending(user => user.Age);

グループ化では、GroupBy を使います。

C#
var groups = users.GroupBy(user => user.Age);

商品をカテゴリごとにグループ化する例です。

C#
var groupedProducts = products.GroupBy(product => product.Category);

「何を基準に並び替えるか」「何を基準にグループ化するか」をラムダ式で指定できるため、処理の意図が明確になります。

5-3. イベントハンドラを短く書く

ラムダ式は、イベントハンドラを書くときにも使えます。

たとえば、ボタンがクリックされたときの処理を短く書けます。

C#
button.Click += (sender, e) =>
{
    Console.WriteLine("ボタンがクリックされました");
};

従来のように別メソッドを作る場合は、次のようになります。

C#
button.Click += Button_Click;

void Button_Click(object? sender, EventArgs e)
{
    Console.WriteLine("ボタンがクリックされました");
}

イベント処理が短く、その場で完結する場合はラムダ式が便利です。

ただし、処理が長い場合や再利用したい場合は、別メソッドに切り出した方が読みやすくなります。

5-4. コールバック処理を渡す

コールバックとは、ある処理が終わった後に呼び出される処理のことです。

ラムダ式を使うと、コールバック処理を簡単に渡せます。

C#
static void Execute(Action callback)
{
    Console.WriteLine("処理を開始します");

    callback();

    Console.WriteLine("処理を終了します");
}

呼び出し側では、次のように書けます。

C#
Execute(() =>
{
    Console.WriteLine("コールバック処理です");
});

引数付きのコールバックも作れます。

C#
static void ProcessUser(string name, Action<string> callback)
{
    callback(name);
}

ProcessUser("田中", name => Console.WriteLine($"{name}さんを処理しました"));

このように、ラムダ式を使うと「後で実行してほしい処理」を柔軟に渡せます。

5-5. 非同期処理やTaskと組み合わせる

ラムダ式は、Task と組み合わせて非同期処理を書くときにも使います。Microsoft Learnでも、Task.Run の引数としてラムダ式を使用する例が示されています。

C#
await Task.Run(() =>
{
    Console.WriteLine("バックグラウンドで処理します");
});

async ラムダも書けます。

C#
Func<Task> loadAsync = async () =>
{
    await Task.Delay(1000);
    Console.WriteLine("読み込み完了");
};

await loadAsync();

イベントハンドラでも、非同期ラムダを使うことがあります。

C#
button.Click += async (sender, e) =>
{
    await Task.Delay(1000);
    Console.WriteLine("クリック後の非同期処理");
};

ただし、非同期ラムダでは例外処理や戻り値の型に注意が必要です。特に async void になる場面は、イベントハンドラ以外では避けるのが基本です。

5-6. メソッドを別に作るべきケースとの判断基準

ラムダ式は便利ですが、何でもラムダ式で書けばよいわけではありません。

次のような場合はラムダ式が向いています。

処理が短い
その場でしか使わない
条件や変換の意図がすぐ分かる
LINQの中で自然に読める

一方、次のような場合はメソッドに切り出した方がよいです。

処理が長い
複数箇所で再利用する
名前を付けた方が意味が伝わる
テストしやすくしたい
複雑な条件分岐がある

たとえば、次のようなラムダ式は少し読みにくくなります。

C#
var result = users.Where(user =>
    user.Age >= 20 &&
    user.Name.StartsWith("A") &&
    user.LastLoginDate >= DateTime.Today.AddDays(-30) &&
    !user.IsDeleted);

この場合は、メソッドに切り出すと意図が明確になります。

C#
var result = users.Where(IsActiveAdultUser);

static bool IsActiveAdultUser(User user)
{
    return user.Age >= 20 &&
           user.Name.StartsWith("A") &&
           user.LastLoginDate >= DateTime.Today.AddDays(-30) &&
           !user.IsDeleted;
}

ラムダ式は短い処理を読みやすくするための道具です。長く複雑になってきたら、メソッド化を検討しましょう。

6. LINQで使うC#ラムダ式の実践例

6-1. Whereで条件に合う要素を抽出する

Where は、条件に合う要素だけを取り出すLINQメソッドです。

C#
var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

var evenNumbers = numbers.Where(n => n % 2 == 0);

Console.WriteLine(string.Join(", ", evenNumbers)); // 2, 4, 6

文字列の例です。

C#
var names = new List<string> { "Alice", "Bob", "Charlie", "Ann" };

var result = names.Where(name => name.Length >= 4);

Console.WriteLine(string.Join(", ", result)); // Alice, Charlie

オブジェクトの例です。

C#
var adults = users.Where(user => user.Age >= 20);

Where に渡すラムダ式は、要素を受け取って bool を返します。

C#
要素 => 条件

条件が true の要素だけが残ります。

6-2. Selectで必要な値に変換する

Select は、要素を別の形に変換するためのメソッドです。

C#
var numbers = new List<int> { 1, 2, 3 };

var doubled = numbers.Select(n => n * 2);

Console.WriteLine(string.Join(", ", doubled)); // 2, 4, 6

ユーザー一覧から名前だけを取り出す例です。

C#
var names = users.Select(user => user.Name);

匿名型に変換することもできます。

C#
var userSummaries = users.Select(user => new
{
    DisplayName = user.Name,
    IsAdult = user.Age >= 20
});

Select は、元のデータを加工して別のデータに変換したいときに使います。

C#
var messages = users.Select(user => $"{user.Name}さんは{user.Age}歳です");

6-3. OrderBy・OrderByDescendingで並び替える

OrderBy は昇順、OrderByDescending は降順で並び替えるメソッドです。

C#
var numbers = new List<int> { 5, 2, 8, 1 };

var ordered = numbers.OrderBy(n => n);

Console.WriteLine(string.Join(", ", ordered)); // 1, 2, 5, 8

降順にする場合です。

C#
var orderedDesc = numbers.OrderByDescending(n => n);

Console.WriteLine(string.Join(", ", orderedDesc)); // 8, 5, 2, 1

ユーザーを年齢順に並び替えます。

C#
var orderedUsers = users.OrderBy(user => user.Age);

年齢が高い順にする場合です。

C#
var olderUsers = users.OrderByDescending(user => user.Age);

複数条件で並び替える場合は、ThenBy や ThenByDescending を使います。

C#
var result = users
    .OrderBy(user => user.Age)
    .ThenBy(user => user.Name);

6-4. First・FirstOrDefaultで最初の要素を取得する

First は、条件に合う最初の要素を取得します。

C#
var numbers = new List<int> { 1, 3, 5, 8, 10 };

var firstEven = numbers.First(n => n % 2 == 0);

Console.WriteLine(firstEven); // 8

ただし、条件に合う要素がない場合、First は例外を発生させます。

C#
var numbers = new List<int> { 1, 3, 5 };

var firstEven = numbers.First(n => n % 2 == 0); // 例外

条件に合う要素がない可能性がある場合は、FirstOrDefault を使います。

C#
var firstEven = numbers.FirstOrDefault(n => n % 2 == 0);

Console.WriteLine(firstEven); // intの既定値である0

参照型の場合、見つからなければ null が返ることがあります。

C#
var user = users.FirstOrDefault(user => user.Name == "田中");

if (user != null)
{
    Console.WriteLine(user.Age);
}

6-5. Any・Allで条件判定する

Any は、条件に合う要素が1つでもあるかを判定します。

C#
var numbers = new List<int> { 1, 3, 5, 8 };

bool hasEven = numbers.Any(n => n % 2 == 0);

Console.WriteLine(hasEven); // True

ユーザー一覧に未成年がいるかを判定します。

C#
bool hasMinor = users.Any(user => user.Age < 20);

All は、すべての要素が条件を満たすかを判定します。

C#
bool allAdults = users.All(user => user.Age >= 20);

Any と All は、if文と組み合わせてよく使われます。

C#
if (users.Any(user => user.Age >= 20))
{
    Console.WriteLine("成人ユーザーがいます");
}

6-6. Count・Sum・Averageで集計する

Count は、条件に合う要素数を数えます。

C#
var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

int evenCount = numbers.Count(n => n % 2 == 0);

Console.WriteLine(evenCount); // 3

Sum は合計を求めます。

C#
var totalAge = users.Sum(user => user.Age);

Average は平均を求めます。

C#
var averageAge = users.Average(user => user.Age);

商品一覧の価格合計を求める例です。

C#
decimal totalPrice = products.Sum(product => product.Price);

条件で絞ってから集計することもできます。

C#
decimal expensiveTotal = products
    .Where(product => product.Price >= 1000)
    .Sum(product => product.Price);

6-7. GroupByでグループ化する

GroupBy は、指定したキーで要素をグループ化します。

商品クラスを考えます。

C#
public class Product
{
    public string Name { get; set; } = "";
    public string Category { get; set; } = "";
    public decimal Price { get; set; }
}

カテゴリごとにグループ化します。

C#
var products = new List<Product>
{
    new Product { Name = "りんご", Category = "食品", Price = 120 },
    new Product { Name = "牛乳", Category = "食品", Price = 200 },
    new Product { Name = "ノート", Category = "文房具", Price = 150 }
};

var groups = products.GroupBy(product => product.Category);

foreach (var group in groups)
{
    Console.WriteLine($"カテゴリ: {group.Key}");

    foreach (var product in group)
    {
        Console.WriteLine(product.Name);
    }
}

グループごとに件数や合計を出すこともできます。

C#
var summary = products
    .GroupBy(product => product.Category)
    .Select(group => new
    {
        Category = group.Key,
        Count = group.Count(),
        TotalPrice = group.Sum(product => product.Price)
    });

6-8. 複数条件を組み合わせるラムダ式

ラムダ式では、&& や || を使って複数条件を組み合わせられます。

C#
var result = users.Where(user => user.Age >= 20 && user.Name.StartsWith("A"));

これは、「20歳以上、かつ名前がAで始まるユーザー」を抽出します。

|| を使うと「または」を表せます。

C#
var result = users.Where(user => user.Age < 20 || user.Age >= 65);

これは、「20歳未満、または65歳以上」のユーザーを抽出します。

条件が長くなる場合は、改行すると読みやすくなります。

C#
var result = users.Where(user =>
    user.Age >= 20 &&
    user.Name.StartsWith("A") &&
    !string.IsNullOrWhiteSpace(user.Name));

さらに複雑になる場合は、メソッドに切り出すのがおすすめです。

C#
var result = users.Where(IsTargetUser);

static bool IsTargetUser(User user)
{
    return user.Age >= 20 &&
           user.Name.StartsWith("A") &&
           !string.IsNullOrWhiteSpace(user.Name);
}

7. LINQのメソッド構文とクエリ構文の違い

7-1. メソッド構文でラムダ式を使う例

LINQには、メソッド構文とクエリ構文があります。

メソッド構文は、Where や Select などのメソッドをつなげて書く方法です。

C#
var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

var result = numbers
    .Where(n => n % 2 == 0)
    .Select(n => n * 10);

この例では、ラムダ式を2回使っています。

C#
n => n % 2 == 0
n => n * 10

メソッド構文では、ラムダ式を使って条件や変換処理を渡します。

オブジェクト一覧でも同じです。

C#
var result = users
    .Where(user => user.Age >= 20)
    .OrderBy(user => user.Name)
    .Select(user => user.Name);

7-2. クエリ構文で同じ処理を書く例

クエリ構文は、SQLに似た書き方でLINQを書く方法です。Microsoft Learnでは、クエリ構文やメソッド構文を含むLINQクエリの基本が説明されています。

先ほどの処理をクエリ構文で書くと、次のようになります。

C#
var result =
    from n in numbers
    where n % 2 == 0
    select n * 10;

ユーザー一覧の例です。

C#
var result =
    from user in users
    where user.Age >= 20
    orderby user.Name
    select user.Name;

クエリ構文では、ラムダ式の => は直接出てきません。しかし、内部的にはLINQのメソッド呼び出しに変換されます。

7-3. 初心者はどちらから学ぶべきか

初心者には、まずメソッド構文から学ぶことをおすすめします。

理由は、実務でラムダ式と一緒に使われる場面が多いからです。

C#
var result = users.Where(user => user.Age >= 20);

この書き方に慣れておくと、Where、Select、OrderBy、Any、FirstOrDefault などを自然に使えるようになります。

一方で、クエリ構文はSQLに慣れている人には読みやすい場合があります。

C#
var result =
    from user in users
    where user.Age >= 20
    select user;

どちらも正しい書き方です。ただし、ラムダ式を理解するという目的では、メソッド構文を優先して学ぶとよいでしょう。

7-4. 実務でラムダ式を使う場面が多い理由

実務でラムダ式を使う場面が多い理由は、メソッド構文のLINQが多用されるからです。

たとえば、Webアプリケーションでは、一覧データを条件で絞り込んだり、表示用の形に変換したりする処理が頻繁にあります。

C#
var viewModels = users
    .Where(user => user.IsActive)
    .OrderBy(user => user.Name)
    .Select(user => new UserViewModel
    {
        Name = user.Name,
        Age = user.Age
    })
    .ToList();

このようなコードは、実務でよく見かけます。

また、Entity Frameworkを使ったデータベース検索でもラムダ式がよく使われます。

C#
var users = dbContext.Users
    .Where(user => user.Age >= 20)
    .ToList();

ラムダ式を読めるようになると、C#の実務コードを理解しやすくなります。

8. ラムダ式でよくあるエラーと解決方法

8-1. 引数の型が推論できないエラー

ラムダ式では、コンパイラが型を推論できないとエラーになります。

たとえば、次のようなコードは意図が不明確です。

C#
var func = x => x * 2; // エラー

x が int なのか、double なのか、ほかの型なのか分からないためです。

解決するには、代入先の型を明示します。

C#
Func<int, int> func = x => x * 2;