ラムダ式と匿名関数

ラムダ式を使用して匿名関数を作成します。 ラムダ宣言演算子=>を使用して、ラムダのパラメーター リストを式本体から分離します。

C# 言語リファレンスには、C# 言語の最新リリース バージョンが記載されています。 また、今後の言語リリースのパブリック プレビューの機能に関する初期ドキュメントも含まれています。

このドキュメントでは、言語の最後の 3 つのバージョンまたは現在のパブリック プレビューで最初に導入された機能を特定します。

ラムダ式には、次の 2 つの形式のいずれかを指定できます。

• 式 の本体として式を持つ式ラムダ:

  (input-parameters) => expression
  

• 本体としてステートメント ブロックを持つステートメント ラムダ:

  (input-parameters) => { <sequence-of-statements> }
  

ラムダ式を作成するには、ラムダ演算子の左側に入力パラメーター (存在する場合) を指定し、もう一方の側に式またはステートメント ブロックを指定します。

任意のラムダ式を デリゲート 型に変換できます。 ラムダ式を変換できるデリゲート型は、そのパラメーターと戻り値の型によって決まります。 ラムダ式が値を返さない場合は、 Action デリゲート型のいずれかに変換します。 値を返す場合は、 Func デリゲート型のいずれかに変換します。 たとえば、2 つのパラメーターを持ち、値を返さないラムダ式を Action<T1,T2> デリゲートに変換します。 1 つのパラメーターを持ち、値を返すラムダ式を Func<T,TResult> デリゲートに変換します。 次の例では、x => x * x という名前のパラメーターを指定し、x の二乗の値を返すラムダ式 x を、デリゲート型の変数に割り当てています。

Func<int, int> square = x => x * x;
Console.WriteLine(square(5));
// Output:
// 25

次の例に示すように、式ラムダを 式ツリー 型に変換することもできます。

System.Linq.Expressions.Expression<Func<int, int>> e = x => x * x;
Console.WriteLine(e);
// Output:
// x => (x * x)

デリゲート型または式ツリーのインスタンスを必要とする任意のコードでラムダ式を使用します。 1 つの例は、バックグラウンドで実行されるコードを渡すための Task.Run(Action) メソッドへの引数です。 また、次の例に示すように、C# で LINQ を作成する場合にもラムダ式を使用できます。

int[] numbers = { 2, 3, 4, 5 };
var squaredNumbers = numbers.Select(x => x * x);
Console.WriteLine(string.Join(" ", squaredNumbers));
// Output:
// 4 9 16 25

メソッド ベースの構文を使用して Enumerable.Select クラス (たとえば、LINQ to Objects、LINQ to XML など) の System.Linq.Enumerable メソッドを呼び出すと、パラメーターはデリゲート型 System.Func<T,TResult> になります。 Queryable.Select クラス (たとえば、LINQ to SQL など) の System.Linq.Queryable メソッドを呼び出すと、パラメーター型は式ツリー型 Expression<Func<TSource,TResult>> になります。 どちらの場合も、同じラムダ式を使用してパラメーター値を指定できます。 これにより、2 つの Select 呼び出しは外観が似ていますが、ラムダから実際に作成されるオブジェクトの型は異なります。

式形式のラムダ

=> 演算子の右辺に式があるラムダ式を "式形式のラムダ" と呼びます。 式形式のラムダは式の結果を返します。基本的な形式は次のとおりです。

(input-parameters) => expression

式形式のラムダの本体を、メソッド呼び出しで構成できます。 ただし、クエリ プロバイダーが評価する 式ツリー を作成する場合は、クエリ プロバイダーがその形式に変換するメソッドの呼び出しを制限します。 クエリ プロバイダーによって、さまざまな機能があります。 たとえば、多くの SQL ベースのプロバイダーは、 String.StartsWith などのメソッドを、 LIKEなどの適切な SQL 式に変換できます。 クエリ プロバイダーがメソッド呼び出しを認識しない場合、式を変換または実行することはできません。

ステートメント形式のラムダ

ステートメント形式のラムダは式形式のラムダに似ていますが、ステートメントが中かっこで囲まれる点が異なります。

(input-parameters) => { <sequence-of-statements> }

ステートメントラムダの本体は、任意の数のステートメントで構成できます。 ただし、実際には、通常は 2 つまたは 3 つ以下です。

Action<string> greet = name =>
{
    string greeting = $"Hello {name}!";
    Console.WriteLine(greeting);
};
greet("World");
// Output:
// Hello World!

ステートメント形式のラムダを使用して式ツリーを作成することはできません。

ラムダ式の入力パラメーター

ラムダ式の入力パラメーターをかっこで囲みます。 空のかっこを使用して、0 個の入力パラメーターを指定します。

Action line = () => Console.WriteLine();

ラムダ式に入力パラメーターが 1 つしかない場合は、かっこを省略できます。

Func<double, double> cube = x => x * x * x;

2 つ以上の入力パラメーターをコンマで区切ります。

Func<int, int, bool> testForEquality = (x, y) => x == y;

通常、コンパイラは、暗黙的に型指定されたパラメーター リストと呼ばれるラムダ式にパラメーターの 型を推論します。 明示的に型を指定できます。これは、 明示的に型指定されたパラメーター リストと呼ばれます。 明示的に型指定されたパラメーター リストの例を次に示します。

Func<int, string, bool> isTooLong = (int x, string s) => s.Length > x;

入力パラメーターの型は、すべて明示的または暗黙的である必要があります。 それ以外の場合は、 CS0748 コンパイラ エラーが発生します。 C# 14 より前のバージョンでは、 ref や outなどの修飾子がある場合は、パラメーターに明示的な型を含める必要があります。 C# 14 では、その制限は削除されます。 ただし、 params 修飾子を使用する場合は、型を宣言する必要があります。

破棄を使用して、式で使用されていないラムダ式の 2 つ以上の入力パラメーターを指定します。

Func<int, int, int> constant = (_, _) => 42;

ラムダの破棄パラメーターは、ラムダ式を使用してイベント ハンドラー指定する場合に役立つことがあります。

明示的に型指定されたパラメーター リストの 既定値 を指定できます。 既定のパラメーター値の構文と制約は、メソッドとローカル関数の場合と同じです。 次の例では、既定のパラメーターを使用してラムダ式を宣言し、既定値を使用して 1 回、2 つの明示的なパラメーターを指定して 1 回呼び出します。

var IncrementBy = (int source, int increment = 1) => source + increment;

Console.WriteLine(IncrementBy(5)); // 6
Console.WriteLine(IncrementBy(5, 2)); // 7

明示的に型指定されたパラメーター リストの最後のパラメーターとして、 params 配列またはコレクションを使用してラムダ式を宣言することもできます。

var sum = (params IEnumerable<int> values) =>
{
    int sum = 0;
    foreach (var value in values) 
        sum += value;
    
    return sum;
};

var empty = sum();
Console.WriteLine(empty); // 0

var sequence = new[] { 1, 2, 3, 4, 5 };
var total = sum(sequence);
Console.WriteLine(total); // 15

これらの更新の一環として、既定のパラメーターが与えられたメソッド グループがラムダ式に割り当てられると、そのラムダ式にも同じ既定のパラメーターが与えられます。 params コレクション パラメーターを持つメソッド グループもラムダ式に割り当てることができます。

パラメーターとして既定のパラメーターまたは params コレクションを使用するラムダ式には、Func<> 型または Action<> 型に対応する自然型がありません。 ただし、既定のパラメーター値が含まれるデリゲート型を定義できます。

delegate int IncrementByDelegate(int source, int increment = 1);
delegate int SumDelegate(params int[] values);
delegate int SumCollectionDelegate(params IEnumerable<int> values);

あるいは、暗黙的に型指定された変数と var 宣言を使用し、デリケート型を定義できます。 コンパイラによって正しいデリゲート型が合成されます。

ラムダ式の既定のパラメーターの詳細については、ラムダ式の機能仕様 の既定のパラメーターを 参照してください。

非同期ラムダ

async キーワードと await キーワードを使用すると、非同期処理を組み込んだラムダ式とステートメントを簡単に作成できます。 たとえば、次のWindows フォーム例には、非同期メソッド ExampleMethodAsync を呼び出して待機するイベント ハンドラーが含まれています。

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        button1.Click += button1_Click;
    }

    private async void button1_Click(object sender, EventArgs e)
    {
        await ExampleMethodAsync();
        textBox1.Text += "\r\nControl returned to Click event handler.\n";
    }

    private async Task ExampleMethodAsync()
    {
        // The following line simulates a task-returning asynchronous process.
        await Task.Delay(1000);
    }
}

非同期ラムダを使用して、同じイベント ハンドラーを追加できます。 このハンドラーを追加するには、次の例に示すように、ラムダ パラメーター リストの前に async 修飾子を追加します。

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        button1.Click += async (sender, e) =>
        {
            await ExampleMethodAsync();
            textBox1.Text += "\r\nControl returned to Click event handler.\n";
        };
    }

    private async Task ExampleMethodAsync()
    {
        // The following line simulates a task-returning asynchronous process.
        await Task.Delay(1000);
    }
}

非同期メソッドの作成および使用方法の詳細については、「Async および Await を使用した非同期プログラミング」を参照してください。

ラムダ式とタプル

C# 言語には、タプルのサポートが組み込まれています。 タプルは、ラムダ式への引数として指定できるほか、ラムダ式で返すこともできます。 場合によっては、C# コンパイラは型推論を使用してタプル要素の型を決定します。

タプルを定義するには、そのコンポーネントのコンマ区切りリストをかっこで囲みます。 次の例では、3 つのコンポーネントを持つタプルを使用して、ラムダ式に連続した数値を渡します。このラムダ式により、各値が 2 倍になり、乗算の結果を格納する 3 つのコンポーネントを持つタプルが返されます。

Func<(int, int, int), (int, int, int)> doubleThem = ns => (2 * ns.Item1, 2 * ns.Item2, 2 * ns.Item3);
var numbers = (2, 3, 4);
var doubledNumbers = doubleThem(numbers);
Console.WriteLine($"The set {numbers} doubled: {doubledNumbers}");
// Output:
// The set (2, 3, 4) doubled: (4, 6, 8)

通常、タプルのフィールド名は Item1、Item2 などのようになります。 ただし、次の例のとおり、名前付きのコンポーネントを持つタプルを定義することができます。

Func<(int n1, int n2, int n3), (int, int, int)> doubleThem = ns => (2 * ns.n1, 2 * ns.n2, 2 * ns.n3);
var numbers = (2, 3, 4);
var doubledNumbers = doubleThem(numbers);
Console.WriteLine($"The set {numbers} doubled: {doubledNumbers}");

C# のタプルの詳細については、タプル型に関するページを参照してください。

標準クエリ演算子を使用したラムダ

LINQ to Objects は、他の実装の中でも、ジェネリック デリゲートの Func<TResult> ファミリの 1 つである型の入力パラメーターを使用します。 これらのデリゲートは、型パラメーターを使用して、入力パラメーターの数と型に加え、デリゲートの戻り値の型を定義します。 Func デリゲートは、一連のソース データ内の各要素に適用されるユーザー定義式をカプセル化するのに役立ちます。 たとえば、Func<T,TResult>デリゲート型を考えてみましょう。

public delegate TResult Func<in T, out TResult>(T arg)

Func<int, bool>が入力パラメーターであり、intが戻り値であるbool インスタンスとしてデリゲートをインスタンス化します。 戻り値は必ず最後の型パラメーターで指定されます。 たとえば、Func<int, string, bool> は 2 つの入力パラメーター ( int と string) と戻り値の型 bool を持つデリゲートを定義しています。 次の Func デリゲートは、呼び出されると、入力パラメーターが 5 に等しいかどうかを示すブール値を返します。

Func<int, bool> equalsFive = x => x == 5;
bool result = equalsFive(4);
Console.WriteLine(result);   // False

引数の型が Expression<TDelegate>の場合 (たとえば、 Queryable 型が定義する標準クエリ演算子など) にラムダ式を指定することもできます。 Expression<TDelegate> 引数を指定すると、ラムダは式ツリーにコンパイルされます。

次の例では、Count 標準クエリ演算子を使用します。

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
int oddNumbers = numbers.Count(n => n % 2 == 1);
Console.WriteLine($"There are {oddNumbers} odd numbers in {string.Join(" ", numbers)}");

コンパイラは、入力パラメーターの型を推論することも、明示的に指定することもできます。 この特定のラムダ式は、2 で除算したときに剰余が 1 になる整数 (n) をカウントします。

次の例では、numbers 配列内で 9 より前にある要素をすべて含むシーケンスを作成します。これは、9 がシーケンス内で条件を満たさない最初の数値であるためです。

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
var firstNumbersLessThanSix = numbers.TakeWhile(n => n < 6);
Console.WriteLine(string.Join(" ", firstNumbersLessThanSix));
// Output:
// 5 4 1 3

次の例では、複数の入力パラメーターをかっこで囲んで指定します。 このメソッドは、値が numbers 配列内のその位置を表す序数よりも小さい数値が出現するまで、その配列に含まれるすべての要素を返します。

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
var firstSmallNumbers = numbers.TakeWhile((n, index) => n >= index);
Console.WriteLine(string.Join(" ", firstSmallNumbers));
// Output:
// 5 4

ラムダ式をクエリ式で直接使用することはありませんが、次の例に示すように、クエリ式内のメソッド呼び出しでそれらを使用できます。

var numberSets = new List<int[]>
{
    new[] { 1, 2, 3, 4, 5 },
    new[] { 0, 0, 0 },
    new[] { 9, 8 },
    new[] { 1, 0, 1, 0, 1, 0, 1, 0 }
};

var setsWithManyPositives = 
    from numberSet in numberSets
    where numberSet.Count(n => n > 0) > 3
    select numberSet;

foreach (var numberSet in setsWithManyPositives)
{
    Console.WriteLine(string.Join(" ", numberSet));
}
// Output:
// 1 2 3 4 5
// 1 0 1 0 1 0 1 0

ラムダ式の型の推定

ラムダを記述する場合、多くの場合、入力パラメーターの型を指定する必要はありません。 コンパイラは、ラムダ本体、パラメーター型、および C# 言語仕様で説明されているその他の要因に基づいて型を推論します。 ほとんどの標準クエリ演算子では、最初の入力がソース シーケンス内の要素の型です。 IEnumerable<Customer>に対してクエリを実行する場合、入力変数は Customer オブジェクトであると推論されます。つまり、そのメソッドとプロパティにアクセスできます。

customers.Where(c => c.City == "London");

ラムダの型推論の一般的な規則は次のとおりです。

• ラムダにはデリゲート型と同じ数のパラメーターが含まれていなければなりません。
• ラムダに含まれる各入力パラメーターは、対応するデリゲート パラメーターに暗黙的に変換できなければなりません。
• ラムダの戻り値 (ある場合) は、デリゲートの戻り値の型に暗黙的に変換できなければなりません。

ラムダ式の自然型

一般的な型システムには "ラムダ式" という組み込みの概念がないため、ラムダ式には型がありません。ただし、ラムダ式の "型" を非公式に話すと便利な場合があります。 このような変則的な "型" は、ラムダ式の変換後のデリゲート型または Expression 型を指します。

ラムダ式には、自然型を指定できます。 ラムダ式の Func<...> や Action<...> などのデリゲート型を宣言する代わりに、コンパイラはラムダ式からデリゲート型を推論します。 たとえば、次のような宣言があるとします。

var parse = (string s) => int.Parse(s);

コンパイラは、 parse が Func<string, int>であると推論します。 適切なものが存在する場合、コンパイラには Func または Action のデリゲートが選択されます。 それ以外の場合は、デリゲート型が合成されます。 たとえば、ラムダ式のパラメーターが ref の場合、デリゲート型が合成されます。 ラムダ式に自然な型がある場合は、 System.Object や System.Delegateなど、明示的でない型に割り当てることができます。

object parse = (string s) => int.Parse(s);   // Func<string, int>
Delegate parse = (string s) => int.Parse(s); // Func<string, int>

正確に 1 つのオーバーロードを持つメソッド グループ (つまり、パラメーター リストのないメソッド名) は、自然型を持ちます。

var read = Console.Read; // Just one overload; Func<int> inferred
var write = Console.Write; // ERROR: Multiple overloads, can't choose

ラムダ式を System.Linq.Expressions.LambdaExpression または System.Linq.Expressions.Expression に割り当て、そのラムダが自然デリゲート型を持つ場合、その式の自然型は System.Linq.Expressions.Expression<TDelegate> であり、自然デリゲート型が型パラメーターの引数として使われます。

LambdaExpression parseExpr = (string s) => int.Parse(s); // Expression<Func<string, int>>
Expression parseExpr = (string s) => int.Parse(s);       // Expression<Func<string, int>>

すべてのラムダ式が自然型を持つわけではありません。 次の宣言を検討します。

var parse = s => int.Parse(s); // ERROR: Not enough type info in the lambda

コンパイラによって s のパラメーター型を推論することはできません。 コンパイラによって自然型を推論できない場合は、型を宣言する必要があります。

Func<string, int> parse = s => int.Parse(s);

明示的な戻り値の型

通常、ラムダ式の戻り値の型は明らかであり、推論されます。 一部の式では、その推論は機能しません。

var choose = (bool b) => b ? 1 : "two"; // ERROR: Can't infer return type

ラムダ式の戻り値の型を入力パラメーターの前に指定することもできます。 明示的な戻り値の型を指定する場合は、入力パラメーターをかっこで囲む必要があります。

var choose = object (bool b) => b ? 1 : "two"; // Func<bool, object>

属性

ラムダ式とそのパラメータに属性を追加できます。 次の例は、ラムダ式に属性を追加する方法を示しています。

Func<string?, int?> parse = [ProvidesNullCheck] (s) => (s is not null) ? int.Parse(s) : null;

次の例に示すように、入力パラメーターまたは戻り値に属性を追加することもできます。

var concat = ([DisallowNull] string a, [DisallowNull] string b) => a + b;
var inc = [return: NotNullIfNotNull(nameof(s))] (int? s) => s.HasValue ? s++ : null;

前の例に示すとおり、ラムダ式またはそのパラメーターに属性を追加する場合は、入力パラメーターをかっこで囲む必要があります。

ラムダ式における外部変数のキャプチャと変数のスコープ

ラムダでは "外部変数" を参照できます。 これらの "外部変数" は、そのラムダ式を定義しているメソッドのスコープ内にある変数、またはそのラムダ式を含む型のスコープ内にある変数です。 この方法で変数をキャプチャすると、ラムダ式は、変数がスコープ外になり、通常はガベージ コレクションされる場合でも、使用するために変数を格納します。 ラムダ式で使用する前に、外部変数を確実に割り当てる必要があります。 次の例は、こうした規則を示しています。

public static class VariableScopeWithLambdas
{
    public class VariableCaptureGame
    {
        internal Action<int>? updateCapturedLocalVariable;
        internal Func<int, bool>? isEqualToCapturedLocalVariable;

        public void Run(int input)
        {
            int j = 0;

            updateCapturedLocalVariable = x =>
            {
                j = x;
                bool result = j > input;
                Console.WriteLine($"{j} is greater than {input}: {result}");
            };

            isEqualToCapturedLocalVariable = x => x == j;

            Console.WriteLine($"Local variable before lambda invocation: {j}");
            updateCapturedLocalVariable(10);
            Console.WriteLine($"Local variable after lambda invocation: {j}");
        }
    }

    public static void Main()
    {
        var game = new VariableCaptureGame();

        int gameInput = 5;
        game.Run(gameInput);

        int jTry = 10;
        bool result = game.isEqualToCapturedLocalVariable!(jTry);
        Console.WriteLine($"Captured local variable is equal to {jTry}: {result}");

        int anotherJ = 3;
        game.updateCapturedLocalVariable!(anotherJ);

        bool equalToAnother = game.isEqualToCapturedLocalVariable(anotherJ);
        Console.WriteLine($"Another lambda observes a new value of captured variable: {equalToAnother}");
    }
    // Output:
    // Local variable before lambda invocation: 0
    // 10 is greater than 5: True
    // Local variable after lambda invocation: 10
    // Captured local variable is equal to 10: True
    // 3 is greater than 5: False
    // Another lambda observes a new value of captured variable: True
}

ラムダ式における変数のスコープには、次の規則が適用されます。

• キャプチャする変数は、それを参照するデリゲートがガベージ コレクションの対象になるまでガベージ コレクションされません。
• ラムダ式内で導入した変数は、外側のメソッドでは表示されません。
• ラムダ式は、外側のメソッドから in、ref、または out パラメーターを直接取り込むことはできません。
• ラムダ式に含まれる return ステートメントで外側のメソッドが戻ることはありません。
• ラムダ式には、ジャンプ ステートメントのターゲットがラムダ式ブロックの外にある場合、goto、break、または continue ステートメントを含めることはできません。 また、ジャンプ先がブロックの内部にある場合に、ラムダ式ブロックの外部でジャンプ ステートメントを使用するとエラーになります。

ラムダによってローカル変数またはインスタンスの状態が意図せずキャプチャされないようにするには、ラムダ式に static 修飾子を適用します。

Func<double, double> square = static x => x * x;

静的ラムダは、外側のスコープからローカル変数またはインスタンスの状態をキャプチャすることはできませんが、静的メンバーと定数定義を参照できます。

C# 言語仕様

詳細については、「C# 言語仕様」の無名関数の式に関するセクションを参照してください。

関連項目

• ラムダの代わりにローカル関数を使用する (スタイル ルール IDE0039)
• C# の演算子と式
• LINQ (Language-Integrated クエリ)
• 式ツリー
• ローカル関数またはラムダ式を選択する
• LINQ サンプル クエリ
• XQuery サンプル