Image credit: codeproject.com
Using Lambda Expressions with CSharp
Using Lambda Expressions with CSharp are a less complex way of representation for anonymous delegates and can be utilized all over the place where these delegates can be applied. Although, Lambda expressions make the work a lot easier, but it requires an expert level syntax constraints following in a similar way as we use LINQ
Why do we use Lambda ?
Lambdas give alternate ways to perform operations on list such as sorting, searching etc., hence, making your code simpler to compose.
Both lambda expressions and anonymous methods are parts of Anonymous functions. For the larger part of circumstances, lambda expression style is best, and you ought to refrain from utilizing Anonymous methods. Practically anything that should be possible utilizing anonymous methods techniques as a part of C# 2.0 should now be possible better with lambda expressions in C# 3.0 on wards.
Why anonymous functions are not as good as lambdas?
There are some disadvantages while utilizing anonymous methods techniques. In the first place, that you can’t utilize the “Edit and Continue” highlight in the Visual Studio Debugger. Not permitted to check an improvement in the method while stepping through the code – rather, you need to rule out your code improvement and restart the debugger again and again.
The other potential issue is that, expecting the code in the anonymous method should be executed as a response to multiple events, a few engineers may wind up duplicating and gluing the code in a few spots of their application, in this manner overlooking the general guideline of code re-use.
The bad and the good for lambda
In the prior versions of Visual Studio before VS 2015, lambdas didn’t support debugging and stepping into the lines but Visual Studio 2015 has removed this limitation
“A lambda expression is an anonymous function that you can use to create delegates or expression tree types. By using lambda expressions, you can write local functions that can be passed as arguments or returned as the value of function calls. Lambda expressions are particularly helpful for writing LINQ query expressions.
To create a lambda expression, you specify input parameters (if any) on the left side of the lambda operator =>, and you put the expression or statement block on the other side. For example, the lambda expression x => x * x specifies a parameter that’s named x and returns the value of x squared. You can assign this expression to a delegate type, as the following example shows:”
delegate int del(int i);
static void Main(string args)
del myDelegate = x => x * x;
int j = myDelegate(5); //j = 25
To create an expression tree type:
static void Main(string args)
Expression<del> myET = x => x * x;
The ease of syntax makes lambda expressions dominate over normal anonymous functions and don’t forget to learn about Lambdas with many working examples in our NEXT POST