Lambda Expression In C#

The concept of lambda expression was introduced in C# 3.0 . The term "Lambda expression" has derived its name from ‘lambda’ calculus, which in turn is a mathematical notation applied for defining functions. A lambda expression is an anonymous function and it is mostly used to create delegates in LINQ. At compile time all the lambda expressions are converted into anonymous methods according to lambda expression conversion rules. Lambda expressions are similar as LINQ equation’s executable part that translate logic in a way at run time so it can pass on to the data source conveniently.

Some advantages of lambda expression are that it allows us to write a method in the same place you are going to use it, especially when we are going to use a method only a single time. In such a way it saves our effort of declaring and writing a separate method to the containing class. Lambda expressions are not just limited to find applications in LINQ only, lambda expressions can also used for further types of calculation.

Syntax:

(input parameters) => expression or statement block

The left side of the lambda operator ("=>") represents the arguments to the method and the right side is the method body.

Let us take some Example:

Example 1:

static void Main(string[] args)
{
List < int > numbers = new List < int > ()
{
1,2,3,4,5,6,7,8,9,10
};
List < int > oddNumbers = numbers.FindAll(x => x % 2 != 0).ToList();
List < int > evenNumbers = numbers.FindAll(x => x % 2 == 0).ToList();
Console.WriteLine("List of Odd Numbers is");
foreach(int ab in oddNumbers)
{
Console.WriteLine(ab);
}
Console.WriteLine("List of Even Numbers is");
foreach(int ab in evenNumbers)
{
Console.WriteLine(ab);
}
Console.ReadKey();
}

Output:

In the above example we created a list of integer type(numbers) and using the lambda expression we separated out even and odd numbers from the list.

Delegates with Lambda Expression:

class Program
{
delegate double del(int x);
static void Main(string[] args)
{
del del1 = (x) => x * x;
del del2 = (x) => Math.Sqrt(x);
List < int > numbers = new List < int > ()
{
1,2,3,4,5,6,7,8,9,10
};
Console.WriteLine("Number Square SquareRoot");
foreach(int ab in numbers)
{
Console.WriteLine("{0} {1} {2}", ab, del1(ab), del2(ab));
}
Console.ReadKey();
}
}

Output:

Output

Example:

static void Main(string[] args)
{
Func < int, int > square = x => x * x;
Func < int, int, int > sum = (x, y) => x + y;
Func < int, int, int > sub = (x, y) => x - y;
Func < int, int, int > mul = (x, y) => x * y;
Func < int, int, int > div = (x, y) => x / y;
int a = 10;
int b = 5;
Console.WriteLine(square.Invoke(a));
Console.WriteLine(square.Invoke(b));
Console.WriteLine(sum.Invoke(a, b));
Console.WriteLine(sub.Invoke(a, b));
Console.WriteLine(mul.Invoke(a, b));
Console.WriteLine(div.Invoke(a, b));
Console.ReadKey();
}

Output:

output

Expression Tree:

Lambda expressions are also used inthe construction of expression tree extensively. An expression tree is similar to a data structure resembling a tree in which every node is itself an expression like a method call, or it can be a binary operation .

Example:

static void Main(string[] args)
{
List < int > numbers = new List < int > ()
{
1,2,3,4,5,6,7,8,9,10
};
foreach(int ab in numbers.Where(x =>
{
if (x % 3 == 0)
return true;
else if (x % 5 == 0)
return true;
else
return false;
}))
{
Console.WriteLine(ab);
}
Console.ReadKey();
}

Output:

output

The below code also generate the same result,

static void Main(string[] args)
{
List < int > numbers = new List < int > ()
{
1,2,3,4,5,6,7,8,9,10
};
foreach(int ab in numbers.Where(x =>
x % 3 == 0 ||
x % 5 == 0
))
{
Console.WriteLine(ab);
}
Console.ReadKey();
}

Lambda Expression with Multiple Statement:

We can wrap expressions in curly braces if you want to have more than one statement in the body.

static void Main(string[] args)
{
List < int > numbers = new List < int > ()
{
1,2,3,4,5,6,7,8,9,10
};
foreach(int ab in numbers.Where(x =>
{
Console.WriteLine("Number is {0}", x);
Console.WriteLine("Sqrt of Value is {0}", Math.Sqrt(x));
return x % 3 == 0 || x % 5 == 0;
}))
{
Console.WriteLine("Returned Number is {0}", ab);
}
Console.ReadKey();
}

Output:

output

Local Variable:

You can declare a variable in the expression body to use it anywhere in the expression body; this variable is only visible with expression body. We can’t access this variable outside the body of expression.

Example:

static void Main(string[] args)
{
List < int > numbers = new List < int > ()
{
1,2,3,4,5,6,7,8,9,10
};
foreach(int ab in numbers.Where(x =>
{
int number = 5;
return x > number;
}))
{
Console.WriteLine("Returned Number is {0}", ab);
}
Console.ReadKey();
}

Output:

output

Points to Consider:

Lambda Expression is a shorter way of representing anonymous method.
Lambda Expression can have zero or more parametes.
Lambda expressions themselves do not have type, so CLR doesn’t support the concept of Lambda expression.
Variables defined within a lambda expression are accessible only within the body of lambda expression.
Lambda expression can have multiple statements in body expression in curly brackets {}.
With in lambda expressions, it is possible to access variables present outside of the lambda expression block by a feature known as closure but vice versa is not possible.
Unsafe code inside any lambda expression can’t be used.
The local variable in lambda expressions is not to be garbage collected unless the delegate referencing the same becomes eligible for the act of garbage collection.
Lambda expressions can also use with Func and Action delegates.