{"id":649,"date":"2022-05-08T17:00:10","date_gmt":"2022-05-08T10:00:10","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=649"},"modified":"2022-06-03T15:14:54","modified_gmt":"2022-06-03T08:14:54","slug":"csharp-lambda-expression","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-lambda-expression\/","title":{"rendered":"C# Lambda Expressions"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about C# lambda expressions and how to use them to define anonymous functions.<\/p>\n\n\n\n

Introduction to C# lambda expressions<\/h2>\n\n\n\n

A lambda expression is an anonymous method<\/a> written in place of a delegate<\/a> instance. A lambda expression is used to create an anonymous function. <\/p>\n\n\n\n

A lambda expression can have one of two forms: expression lambda and statement lambda. <\/p>\n\n\n\n

An expression lambda has an expression in its body:<\/p>\n\n\n

(parameters) => expression<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
A statement lambda has a statement block as its body:<\/p>\n\n\n
(parameters) => { statements; }<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this syntax, the =><\/code> is called the lambda operator. <\/p>\n\n\n\n
To form a lambda expression, you specify input parameters on the left side of the lambda operator and an expression or statement block on the right side.<\/p>\n\n\n\n
If a lambda expression doesn’t have any input parameter, you can use an empty parentheses ()<\/code>. For example:<\/p>\n\n\n
() => expression;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
If a lambda expression has exactly one parameter and the C# compiler can infer the type of the parameter, you can omit the parentheses like this:<\/p>\n\n\n
Func<T, TResult> lambda = parameter => expression;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
If a lambda expression has multiple parameters, you can use a comma to separate between two parameters as follows:<\/p>\n\n\n
(p1, p2, p3) => expression;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
C# lambda expression examples<\/h2>\n\n\n\n
The following example defines a lambda expression that returns the square of an integer:<\/p>\n\n\n
var<\/span> square = (int<\/span> x) => x * x;\nvar<\/span> result = square(10<\/span>);\n\nConsole.WriteLine(result); \/\/ 100<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the following is a lambda expression:<\/p>\n\n\n
(int<\/span> x) => x * x;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
It accepts an integer and returns the square of that integer.<\/p>\n\n\n\n
If you want to use the statement lambda, you need to use a return statement inside the statement block. For example:<\/p>\n\n\n
var<\/span> square = (int<\/span> x) =>\n{\n    return<\/span> x * x;\n};\n\nvar<\/span> result = square(10<\/span>);\nConsole.WriteLine(result); \/\/ 100<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Note that you can explicitly specify the return type of a lambda expression. For example, the following explicitly uses int as the return type of the lambda expression:<\/p>\n\n\n
var<\/span> square = int<\/span> (int<\/span> x) => x * x;\nvar<\/span> result = square(10<\/span>);\n\nConsole.WriteLine(result); \/\/ 100<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
When the C# compiler encounters a lambda expression, it converts the lambda expression to a delegate instance. In the above example, the C# compiler converts the lambda expression to Func<int,int><\/code>. See the following example:<\/p>\n\n\n
Func<int<\/span>,int<\/span>> square = x => x * x;\nvar<\/span> result = square(10<\/span>);\n\nConsole.WriteLine(result); \/\/ 100<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we declare the square<\/code> as an instance of the Func<int,int><\/code>.  <\/p>\n\n\n\n
Because the Func<int, int><\/code> accepts an integer and returns an integer, we don’t need to explicitly specify the type for the input parameter of the lambda expression. Therefore, we can omit the parentheses.<\/p>\n\n\n\n
Capturing outer variables<\/h2>\n\n\n\n
A lambda expression can reference any variables including local variables, parameters, and members that are accessible from the location where you define the lambda expression. These variables are called outer variables<\/strong>.<\/p>\n\n\n\n
The variables referenced by a lambda expression are known as captured variables<\/strong>. When a lambda expression has captured variables, it is called a closure<\/strong>. For example:<\/p>\n\n\n
int<\/span> factor = 10<\/span>;\n\nvar<\/span> multiplier = (int<\/span> x) => x * factor;\n\nvar<\/span> result = multiplier(10<\/span>);\n\nConsole.WriteLine(result); \/\/ 100<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the lambda expression references the local variable factor<\/code>. The factor<\/code> variable is called an outer variable. And the lambda expression is a closure.<\/p>\n\n\n\n
It’s important to note that the lambda expression evaluates the captured variables when it is executed, not when the variables were captured. For example:<\/p>\n\n\n
var<\/span> multipliers = new<\/span> List<Func<int<\/span>, int<\/span>>>();\n\nfor<\/span>(int<\/span> i = 1<\/span>; i <= 3<\/span>; i++)\n{\n    multipliers.Add((int<\/span> x) => x*i);\n}\n\n\n\nforeach<\/span> (var<\/span> multipler in<\/span> multipliers)\n{\n    int<\/span> result = multipler(10<\/span>);\n    Console.WriteLine(result);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, define a list of lambda expressions that accept an integer and return an integer:<\/p>\n\n\n
var<\/span> multipliers = new<\/span> List<Func<int<\/span>, int<\/span>>>();<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, add three multipliers to the list. Each multiplier will multiply its argument by 1, 2, and 3.<\/p>\n\n\n
for<\/span>(int<\/span> i = 1<\/span>; i <= 3<\/span>; i++)\n{\n    multipliers.Add((int<\/span> x) => x*i);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Third, iterate over the lambda expression list and execute each of them:<\/p>\n\n\n
foreach<\/span> (var<\/span> multipler in<\/span> multipliers)\n{\n    int<\/span> result = multipler(10<\/span>); \/\/ multipler uses 4<\/span>\n    Console.WriteLine(result);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The output is not what you may expect:<\/p>\n\n\n
40<\/span>\n40<\/span>\n40<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
It returns the same result (40) for the three lambda expressions.<\/p>\n\n\n\n
The reason is that after the first for loop, the variable i<\/code> is 4. Because the lambda expressions evaluate the capture variables at the time of invocation, not at the defined time. Therefore, all three lambda expressions use the same value of the variable i<\/code>.<\/p>\n\n\n\n
To fix this, you need to create a local variable inside the for<\/code> loop and use that variable as the captured variable for the lambda expressions, like this:<\/p>\n\n\n
var<\/span> multipliers = new<\/span> List<Func<int<\/span>, int<\/span>>>();\n\nfor<\/span>(int<\/span> i = 1<\/span>; i <= 3<\/span>; i++)\n{\n    int<\/span> factor = i;\n    multipliers.Add((int<\/span> x) => x*factor);\n}\n\nforeach<\/span> (var<\/span> multipler in<\/span> multipliers)\n{\n    int<\/span> result = multipler(10<\/span>); \n    Console.WriteLine(result);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
10<\/span>\n20<\/span>\n30<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, each iteration creates a new factor<\/code> variable. Therefore, each lambda expression captures a different variable. <\/p>\n\n\n\n
Static lambda expressions<\/h2>\n\n\n\n
When a lambda expression captures variables, the C# compiler needs to create a private class and instantiate it to store a reference to the captured variables. This incurs a small performance.<\/p>\n\n\n\n
Starting with C# 9, you can use a static keyword to ensure that the lambda expression doesn’t capture any variables. For example:<\/p>\n\n\n
var<\/span> square = static<\/span> (int<\/span> x) => x * x;\nvar<\/span> result = square(10<\/span>);\n\nConsole.WriteLine(result); \/\/ 100<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
When you use the static<\/code> keyword and capture variables, the C# compiler will issue an error. For example:<\/p>\n\n\n
int<\/span> factor = 2<\/span>;\nvar<\/span> square = static<\/span> (int<\/span> x) => x * factor; \/\/ ERROR<\/span>\n\nvar<\/span> result = square(10<\/span>);\nConsole.WriteLine(result); \/\/ 100<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Summary<\/h2>\n\n\n\n
  • A lambda expression defines an anonymous function.<\/li>
  • A lambda expression can capture variables.<\/li>
  • When a lambda expression contains captured variables, it’s called a closure.<\/li>
  • A lambda expression evaluates the captured variables at the time of invocation.<\/li><\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t\n\t\t\t