Lambda Expression in C#

« Previous

Anonymous methods can be used in the place where there is a use of a delegate. Lambda Expression is extension of anonymous method. A lambda expression is an anonymous function that can contain expressions and statements. The term lambda expression comes from lambda calculus. In mathematics it is denoted as λ, where λ is the Greek letter lambda.

Lambda expressions provide same functionality, as anonymous methods can do. They are more readable and compact.

Lambda expressions use the lambda operator =>, which is read as "goes to".

Example:
The lambda expression x => x * x is read "x goes to x multiply by x."

The left side of the lambda operator indicates the input parameters and the right side shows the expression or statement block.

Example

using System;
namespace ConsoleApplication1
{
    class Program
    {
        delegate int delDemo(int n);
        static void Main(string[] args)
        {
            delDemo delObj = y => y * y;
            Console.WriteLine("Enter a number");
            int x = Convert.ToInt32(Console.ReadLine());
            int j = delObj(x);
            Console.WriteLine("The squre of {0} is {1}",x,j);
            Console.ReadLine();
        }
    }
}

Statement Lambda

A statement lambda looks like an expression lambda, but the statement(s) should be enclosed in braces.

Syntax of statement lambda:

(Input parameters) => {statements}

Example

using System;
namespace ConsoleApplication1
{
    class Program
    {
        delegate int factDelegate(int n);
        static void Main(string[] args)
        {
            int fact = 1;
            factDelegate delObj = y => {
                for (int i = 1; i <= y; i++)
                {
                    fact = fact * i;
                }
                return fact;
            };
            Console.WriteLine("Enter a number");
            int x = Convert.ToInt32(Console.ReadLine());
            int j = delObj(x);
            Console.WriteLine("The factorial of {0} is {1}", x, j);
            Console.ReadLine();
        }
    }
}

Func and Action built-in generic delegate

For using delegate we have to use following procedure

Declare a delegate.
Create methods with implementation. Methods prototype should be same as delegate.
Create instance of delegate and refer to method.

If you don’t want to create custom delegate, then you can use Func delegate type. C# 3.0 provides Func built-in generic delegate types, that is located in the System namespace.

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

Func delegate enables you to create a method that can be passed as a parameter without explicitly declaring a custom delegate. This delegate can refer to a method that takes up to 16 Parameters and returns a value. The last type parameter is used for the return type.

Signatures of the Func delegate types in .NET 3.5:

TResult Func<TResult>()
TResult Func<T,TResult>(T arg)
TResult Func<T1,T2,TResult>(T1 arg1, T2 arg2)
TResult Func<T1,T2,T3,TResult>(T1 arg1, T2 arg2, T3 arg3)
TResult Func<T1,T2,T3,T4,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4)

Example

using System;
namespace ConsoleApplication1
{
    class FuncDemo
    {
        //ShowWelcome() method does not take parameter and return string type.
        public string ShowWelcome()
        {
            return string.Format("Welcome at TutorialRide");
        }
        //Add method takes two parameter and return one integer type.
        public int Add(int a, int b)
        {
            return a + b;
        }
        //ShowInformation method takes two string parameter and return one string type.
        public string ShowInformation(string firstName, string lastName)
        {
            return string.Format("Your Name is {0} {1}", firstName, lastName);
        }
    }
    class Program
    {

        static void Main(string[] args)
        {
            FuncDemo obj = new FuncDemo();
            Func<string> welcomeObj = obj.ShowWelcome;
            Func<int, int, int> addObj = obj.Add;
            Func<string, string, string> showObj = obj.ShowInformation;
            Console.WriteLine("Enter the First Number");
            int a = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("Enter the Second Number");
            int b = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("Enter the First Name");
            string firstName = Console.ReadLine();
            Console.WriteLine("Enter the Last Name");
            string lastName =Console.ReadLine();
            Console.WriteLine("\n**********************\n");
            Console.WriteLine(welcomeObj());
            Console.WriteLine("The addition of {0} and {1} is = {2}",a,b,addObj(a,b));
            Console.WriteLine(showObj(firstName,lastName));
            Console.WriteLine("\n**********************\n");
            Console.ReadLine();

        }
    }
}

Output:

Enter the First Number
10
Enter the Second Number
20
Enter the First Name
Raj
Enter the Last Name
Parihar

**************************************
Welcome at TutorialRide
The addition of 10 and 20 is = 30
Your Name is Raj Parihar
*************************************

Action delegate

The Action delegate provides the equivalent functionality as Func. It is used for a function that may or may not take parameters and does not return a value.

Func delegate works only for those methods, which has return type.

« Previous