Click here to Skip to main content
Click here to Skip to main content

Tagged as

Anonymous Methods and Lambda features in C#

, 2 Jul 2014 CPOL
Rate this:
Please Sign up or sign in to vote.
Anonymous methods and lambda features in C#

Introduction

A number of articles are available on the web related to Anonymous methods and Lambda expression features. It is very confusing for the developers to decide when and where to use these features. I have tried to explain the concept in very simple manner.

Anonymous Methods

Anonymous method is a beautiful feature introduced in C# 2.0.

Anonymous methods are self explanatory that says "No Name” meaning anonymous methods let you declare a method body without giving it a name. Simply anonymous method has only body without name, optional parameters and return type.

Anonymous methods can only be created when using delegates. It acts as normal methods behind the scene but there is no way to explicitly call them in your code.

Sample C# Syntax

Delegate void TestDel(int n);
...
TestDel nc = delegate (int x)
{
    Console.WriteLine("Anonymous Method: {0}", x);
};

Delegates are known to be function pointers meaning to be pointing to a function.

Let’s have an example to explain this.

Here, we have a customers class having empID, EmpName and Salary properties defined.

Below, we are trying to use find method which basically accepts a predicate of employee as parameter. Predicate is nothing but a predefined delegate which returns bool.

So the code below has anonymous method which has delegate and it is returning bool true matching empID 3.

customers custDisply= lstCust.Find(delegate(customers cust)
            {
               return cust.EmpID==3;
            });

Sample Code

public class Program
    {
        public class customers
        {
            public int EmpID { get; set; }
            public string EmpName { get; set; }
            public float salary { get; set; }

        }
        static void Main(string[] args)
        {
            List<customers> lstCust = new List<customers>
            {
                new customers{EmpID=1,EmpName="Abhishek",salary=10000},
                new customers{EmpID=2,EmpName="David",salary=20000},
                new customers{EmpID=3,EmpName="Suman",salary=40000}
            };

           customers custDisply= lstCust.Find(
               delegate(customers cust)
            {
               return cust.EmpID==3;
            });
        Console.WriteLine("{0},{1},{2}",custDisply.EmpID,custDisply.EmpName,custDisply.salary);

            Console.ReadLine();            
        }
    }

Anonymous method in event handling:

        Button btnDisplay = new Button();
            btnDisplay.Text = "Click";
            btnDisplay.Click +=
                delegate(object sender, EventArgs e)
                {
                    MessageBox.Show("Hello Every Body....");
                };
         Controls.Add(btnDisplay);

Important Sticky

  • A variable, declared outside the anonymous method can be accessed inside the anonymous method.
  • A variable, declared inside the anonymous method can’t be accessed outside the anonymous method.
  • We use anonymous method in event handling.
  • An anonymous method, declared without parenthesis can be assigned to a delegate with any signature.
  • An anonymous method can’t access the ref or out parameters of an outer scope.

Lambda Expressions

Lambda concept has been introduced in C# version 3.0.

Lambda expression is an inline delegate which provides a way to represent anonymous methods. Anonymous methods and Lambda expression are very similar.

It is used to create delegates or expression tree types and after compilation, lambda expressions are converted into anonymous methods.

Lambda Syntax

(Parameters) => expression-or-statement-block
=> Lambda Operator
Left side of the lambda operator "=>" represents the arguments to the method
Right side is the method body having expression or statement block
Let me explain the method call by an example.
Below we can see

Delegate int delDisplay(int i);

static void Main(string[] args)
{
    delDisplay del = x => x * x;
    int j = del (5); 
 }
// result j = 25

Using Lambda Expression

using System.Linq.Expressions;

namespace MyLambda
{
    class Program
    {
        static void Main(string[] args)
        {
            Expression<del> myET = x => x * x;
        }
    }
}

When we see the example from the above anonymous method:

customers custDisply= lstCust.Find(delegate(customers cust)
            {
               return cust.EmpID==3;
            });

We can see delegate keyword and type of parameter provided for anonymous method.

Using Lambda, the same code can be rewritten as:

customers cusLambda = lstCust.Find(emp => emp.EmpID == 3);

So basically, we need not use delegate keyword explicitly and also need not specify type of input parameter. Lambda expressions are simpler to use than anonymous methods.

Sample Code

class Program
    {
        public class customers
        {
            public int EmpID { get; set; }
            public string EmpName { get; set; }
            public float salary { get; set; }
        }
        static void Main(string[] args)
        {
            List<customers> lstCust = new List<customers>
            {
                new customers{EmpID=1,EmpName="Abhishek",salary=10000},
                new customers{EmpID=2,EmpName="David",salary=20000},
                new customers{EmpID=3,EmpName="Akash",salary=40000}
            };

           customers cusLambda = lstCust.Find(emp => emp.EmpID == 3);

           int count = lstCust.Count(X => X.EmpName.StartsWith("A"));

           Console.WriteLine("Count :" + count);

           Console.WriteLine("{0},{1},{2}", cusLambda.EmpID, cusLambda.EmpName, cusLambda.salary);

    Console.ReadLine();            
        }
    }

Lambda Expression Types

  • statement lambda

    Statement lambda has a statement block on the right side of the lambda operator "=>".

  • Expression lambda

    Expression lambda has only an expression (no return statement or curly braces), on the right side of the lambda operator "=>".

Important Sticky

  • We need not use delegate keyword explicitly and also need not specify type of input parameter with lambda expressions.
  • A lambda expression cannot be assigned to an implicitly typed local variable since the lambda expressions do not have type.
  • Variables defined within a lambda expression are accessible only within the scope of the lambda expression body.
  • Lambda expression can be broken down into parameters.

Summary

Anonymous methods and lambda expression provide a way to use inline way of code. They will reduce the lines of code and are useful in places where a method is being used only once and the method definitions are short. It saves you the effort of declaring and writing a separate method to the containing class.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Abhishek Geek
Technical Lead
India India
No Biography provided

Comments and Discussions

 
QuestionGood Understandable and readable contents.. PinprofessionalRajeev Kr. Singh8-Jul-14 22:09 
GeneralMy vote of 5 PinprofessionalBrian A Stephens2-Jul-14 4:40 
GeneralRe: My vote of 5 PinprofessionalAbhishek Geek2-Jul-14 23:10 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.1411023.1 | Last Updated 2 Jul 2014
Article Copyright 2014 by Abhishek Geek
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid