Beginners guide to Lambda Expressions

I recently attended a session on LINQ where everything related to LINQ had been the part of discussion, including Lambda Expressions and after feeling of expressing my views I came to write this post. Developers who are either from C++ or working on C# 2.0 still might not have a clear vision of Lambda Expressions. What are Lambda Expressions?, When & Where to use ?, Why to use ? These are the basic question that can come to mind when anybody hears of new programming things. Through this post I'll try to answer these question. There are new terms that are being introduced with every release of .Net framework, so lets get started with Lambda Expression for now:

What is a Lambda Expression?

Lambda expressions are similar to anonymous methods introduced in C# 2.0, except that lambda expressions are more concise and more flexible. All lambda expressions use the lambda operator =>, which is read as "goes to". The left side of the lambda operator specifies the input parameters and the right side holds the expression or statement block.

Lets take an example:

delegate int anonymousDel (int i);

With C# 2.0, anonymous methods allow you to write a method and initialize a delegate in place:

            anonymousDel myDelegate = new anonymousDel(
            delegate(int x)
            {
                return x * 2;
            });

            Console.WriteLine("{0}", myDelegate(5));

The segment inside the braces of anonymousDel is also called as Anonymous Function.

Now lets convert it to a Lambda Expression:

anonymousDel myDelegate = x => x * 2;

x => x * 2 is the expression that is the known as Lambda Expression. All lambda expressions use the lambda operator =>, which is read as "goes to". The left side of the lambda operator specifies the input parameters (if any) and the right side hold the expression or statement block. The lambda expression x => x * 2 is read "x goes to 2 times x." This reduced the no. of lines as you can see and the output is still the same.

The above expression can be generalized for clearer understanding.

(input parameters) => Expression;

and can be called as "Expression Lambdas" since single Expression is involved here.

It can contain multiple statements and can be surrounded by { } just like anonymous functions.

(input param1, input param2) => { statement1, Statement 2};

        for e.g. delegate int anonmousDel2(int a, int b);
        anonmousDel2 getBigInteger = (x, y) => { if (x > y) return x; else return y; };
        Console.WriteLine(getBigInteger(10,15));

You can raise a question here, how x & y are being treated as integer while you didn't declared them as integer?

Here is the answer. When writing lambdas, you often do not have to specify a type for the input parameters because the compiler can infer the type based on the lambda body, the underlying delegate type, and other factors as described in the C# Language Specification.

Anonymous function that take no parameter and return nothing can be written in form of a Lambda Expression like below:

        delegate void doSomething();
        doSomething IamVoid = () => { Console.WriteLine("Hello there! I take nothing and return nothing"); };
            //call the Anonymous function
            IamVoid();

When & Where to use Lambda Expressions?

Whenever you came to know about a new term and you have learned what it is, then you ask yourself when & where it would be used. Lambda Expressions can be used to simply replacing Anonymous functions, In the LINQ query methods, or anywhere you have to initialize Generic delegates.

LINQ Query example:

LINQ to Objects

    int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };

    int oddNumbers = numbers.Count(n => n % 2 == 1);

LINQ to SQL

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

LINQ To XML

    var xml = element.Descendants("customer").Where(cust => cust.Attribute("id").Value == CustomerId).SingleOrDefault();

Func<>, Action<> and Expression<> are the new generic delegates where you can use Lambda Expressions. Don't panic with these new terms.  Lets look at an example where these new generic delegates can be used. See the below code snippet:

    delegate int anonmousDel2(int a, int b);

    anonmousDel2 getBigInteger = (x, y) => { if (x > y) return x; else return y; };

    Console.WriteLine(getBigInteger(10,15));

Lets modify this using generic delegates and Lambda Expressions

    Func<int, int, int> getBigInteger;

    getBigInteger = (x, y) => { if (x > y) return x; else return y; };

    Console.WriteLine(getBigInteger(10,15));

Explanation Func<int, int, int> of would be

    Func<parameter1, parameter2, returntype>

You can pass any number of arguments but the last mentioned type would be the type of returned value. Similary we use Action<param1, param2> in this because we don't need to return any value. It tells the Generic delegate that you have a return type of void. These delegates were introduced to provide a taste of Functional Progamming in C# itself. if you are still interested in reading further into it then its worth it for me writing this post.

When to use Lambda Expressions?

Use them whenever you feel you can reduce your lines of code. Keep in mind the  maintainability while reducing the number of lines of code. People think that Lambda Expressions are awkward looking code, but I'm telling you its worth it to use them in code wisely. Once you understood the concept you'll love it. If you are going to use excess of LINQ in your code then Lambda Expressions will be your favorite buddy. Helping you wrap your code logic in fewer lines or maybe InLine.