C# Lambda expressions: Why should I use them?

C#C# 3.0Lambda

C# Problem Overview

I have quickly read over the Microsoft Lambda Expression documentation.

This kind of example has helped me to understand better, though:

delegate int del(int i);
del myDelegate = x => x * x;
int j = myDelegate(5); //j = 25

Still, I don't understand why it's such an innovation. It's just a method that dies when the "method variable" ends, right? Why should I use this instead of a real method?

C# Solutions

Solution 1 - C#

Lambda expressions are a simpler syntax for anonymous delegates and can be used everywhere an anonymous delegate can be used. However, the opposite is not true; lambda expressions can be converted to expression trees which allows for a lot of the magic like LINQ to SQL.

The following is an example of a LINQ to Objects expression using anonymous delegates then lambda expressions to show how much easier on the eye they are:

// anonymous delegate
var evens = Enumerable
                .Range(1, 100)
                .Where(delegate(int x) { return (x % 2) == 0; })

// lambda expression
var evens = Enumerable
                .Range(1, 100)
                .Where(x => (x % 2) == 0)

Lambda expressions and anonymous delegates have an advantage over writing a separate function: they implement closures which can allow you to pass local state to the function without adding parameters to the function or creating one-time-use objects.

Expression trees are a very powerful new feature of C# 3.0 that allow an API to look at the structure of an expression instead of just getting a reference to a method that can be executed. An API just has to make a delegate parameter into an Expression<T> parameter and the compiler will generate an expression tree from a lambda instead of an anonymous delegate:

void Example(Predicate<int> aDelegate);

called like:

Example(x => x > 5);


void Example(Expression<Predicate<int>> expressionTree);

The latter will get passed a representation of the abstract syntax tree that describes the expression x > 5. LINQ to SQL relies on this behavior to be able to turn C# expressions in to the SQL expressions desired for filtering / ordering / etc. on the server side.

Solution 2 - C#

Anonymous functions and expressions are useful for one-off methods that don't benefit from the extra work required to create a full method.

Consider this example:

 List<string> people = new List<string> { "name1", "name2", "joe", "another name", "etc" };
 string person = people.Find(person => person.Contains("Joe"));


 public string FindPerson(string nameContains, List<string> persons)
     foreach (string person in persons)
         if (person.Contains(nameContains))
             return person;
     return null;

These are functionally equivalent.

Solution 3 - C#

I found them useful in a situation when I wanted to declare a handler for some control's event, using another control. To do it normally you would have to store controls' references in fields of the class so that you could use them in a different method than they were created.

private ComboBox combo;
private Label label;

public CreateControls()
	combo = new ComboBox();
	label = new Label();
	//some initializing code
	combo.SelectedIndexChanged += new EventHandler(combo_SelectedIndexChanged);

void combo_SelectedIndexChanged(object sender, EventArgs e)
    label.Text = combo.SelectedValue;

thanks to lambda expressions you can use it like this:

public CreateControls()
    ComboBox combo = new ComboBox();
    Label label = new Label();
    //some initializing code
    combo.SelectedIndexChanged += (s, e) => {label.Text = combo.SelectedValue;};

Much easier.

Solution 4 - C#

Lambda's cleaned up C# 2.0's anonymous delegate syntax...for example

Strings.Find(s => s == "hello");

Was done in C# 2.0 like this:

Strings.Find(delegate(String s) { return s == "hello"; });

Functionally, they do the exact same thing, its just a much more concise syntax.

Solution 5 - C#

This is just one way of using a lambda expression. You can use a lambda expression anywhere you can use a delegate. This allows you to do things like this:

List<string> strings = new List<string>();

strings.Find(s => s == "hello");

This code will search the list for an entry that matches the word "hello". The other way to do this is to actually pass a delegate to the Find method, like this:

List<string> strings = new List<string>();

private static bool FindHello(String s)
    return s == "hello";



In C# 2.0, this could be done using the anonymous delegate syntax:

  strings.Find(delegate(String s) { return s == "hello"; });

Lambda's significantly cleaned up that syntax.

Solution 6 - C#

Microsoft has given us a cleaner, more convenient way of creating anonymous delegates called Lambda expressions. However, there is not a lot of attention being paid to the expressions portion of this statement. Microsoft released a entire namespace, System.Linq.Expressions, which contains classes to create expression trees based on lambda expressions. Expression trees are made up of objects that represent logic. For example, x = y + z is an expression that might be part of an expression tree in .Net. Consider the following (simple) example:

using System;
using System.Linq;
using System.Linq.Expressions;

namespace ExpressionTreeThingy
    class Program
        static void Main(string[] args)
            Expression<Func<int, int>> expr = (x) => x + 1; //this is not a delegate, but an object
            var del = expr.Compile(); //compiles the object to a CLR delegate, at runtime
            Console.WriteLine(del(5)); //we are just invoking a delegate at this point

This example is trivial. And I am sure you are thinking, "This is useless as I could have directly created the delegate instead of creating an expression and compiling it at runtime". And you would be right. But this provides the foundation for expression trees. There are a number of expressions available in the Expressions namespaces, and you can build your own. I think you can see that this might be useful when you don't know exactly what the algorithm should be at design or compile time. I saw an example somewhere for using this to write a scientific calculator. You could also use it for Bayesian systems, or for genetic programming (AI). A few times in my career I have had to write Excel-like functionality that allowed users to enter simple expressions (addition, subtrations, etc) to operate on available data. In pre-.Net 3.5 I have had to resort to some scripting language external to C#, or had to use the code-emitting functionality in reflection to create .Net code on the fly. Now I would use expression trees.

Solution 7 - C#

It saves having to have methods that are only used once in a specific place from being defined far away from the place they are used. Good uses are as comparators for generic algorithms such as sorting, where you can then define a custom sort function where you are invoking the sort rather than further away forcing you to look elsewhere to see what you are sorting on.

And it's not really an innovation. LISP has had lambda functions for about 30 years or more.

Solution 8 - C#

You can also find the use of lambda expressions in writing generic codes to act on your methods.

For example: Generic function to calculate the time taken by a method call. (i.e. Action in here)

public static long Measure(Action action)
	Stopwatch sw = new Stopwatch();
	return sw.ElapsedMilliseconds;

And you can call the above method using the lambda expression as follows,

var timeTaken = Measure(() => yourMethod(param));

Expression allows you to get return value from your method and out param as well

var timeTaken = Measure(() => returnValue = yourMethod(param, out outParam));

Solution 9 - C#

Lambda expression is a concise way to represent an anonymous method. Both anonymous methods and Lambda expressions allow you define the method implementation inline, however, an anonymous method explicitly requires you to define the parameter types and the return type for a method. Lambda expression uses the type inference feature of C# 3.0 which allows the compiler to infer the type of the variable based on the context. It’s is very convenient because that saves us a lot of typing!

Solution 10 - C#

A lambda expression is like an anonymous method written in place of a delegate instance.

delegate int MyDelagate (int i);
MyDelagate delSquareFunction = x => x * x;

Consider the lambda expression x => x * x;

>The input parameter value is x (on the left side of =>) > >The function logic is x * x (on the right side of =>)

A lambda expression's code can be a statement block instead of an expression.

x => {return x * x;};


Note: Func is a predefined generic delegate.

    Console.WriteLine(MyMethod(x => "Hi " + x));

    public static string MyMethod(Func<string, string> strategy)
        return strategy("Lijo").ToString();


  1. https://stackoverflow.com/questions/2012095/c-sharp-how-can-a-delegate-interface-method-interchangable/20703787#20703787

Solution 11 - C#

A lot of the times, you are only using the functionality in one place, so making a method just clutters up the class.

Solution 12 - C#

It's a way of taking small operation and putting it very close to where it is used (not unlike declaring a variable close to its use point). This is supposed to make your code more readable. By anonymizing the expression, you're also making it a lot harder for someone to break your client code if it the function is used somewhere else and modified to "enhance" it.

Similarly, why do you need to use foreach? You can do everything in foreach with a plain for loop or just using IEnumerable directly. Answer: you don't need it but it makes your code more readable.

Solution 13 - C#

The innovation is in the type safety and transparency. Although you don't declare types of lambda expressions, they are inferred, and can be used by code search, static analysis, refactoring tools, and runtime reflection.

For example, before you might have used SQL and could get an SQL injection attack, because a hacker passed a string where a number was normally expected. Now you would use a LINQ lambda expression, which is protected from that.

Building a LINQ API on pure delegates is not possible, because it requires combining expression trees together before evaluating them.

In 2016 most of the popular languages have lambda expression support, and C# was one of the pioneers in this evolution among the mainstream imperative languages.

Solution 14 - C#

This is perhaps the best explanations on why to use lambda expressions -> https://youtu.be/j9nj5dTo54Q

In summary, it's to improve code readability, reduce chances of errors by reusing rather than replicating code, and leverage optimization happening behind the scenes.

Solution 15 - C#

The biggest benefit of lambda expressions and anonymous functions is the fact that they allow the client (programmer) of a library/framework to inject functionality by means of code in the given library/framework ( as it is the LINQ, ASP.NET Core and many others ) in a way that the regular methods cannot. However, their strength is not obvious for a single application programmer but to the one that creates libraries that will be later used by others who will want to configure the behaviour of the library code or the one that uses libraries. So the context of effectively using a lambda expression is the usage/creation of a library/framework.

Also since they describe one-time usage code they don't have to be members of a class where that will led to more code complexity. Imagine to have to declare a class with unclear focus every time we wanted to configure the operation of a class object.


All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionPatrick DesjardinsView Question on Stackoverflow
Solution 1 - C#Neil WilliamsView Answer on Stackoverflow
Solution 2 - C#Joseph DaigleView Answer on Stackoverflow
Solution 3 - C#agnieszkaView Answer on Stackoverflow
Solution 4 - C#FlySwatView Answer on Stackoverflow
Solution 5 - C#Scott DormanView Answer on Stackoverflow
Solution 6 - C#Jason JacksonView Answer on Stackoverflow
Solution 7 - C#workmad3View Answer on Stackoverflow
Solution 8 - C#GunasekaranView Answer on Stackoverflow
Solution 9 - C#Vijesh VPView Answer on Stackoverflow
Solution 10 - C#LCJView Answer on Stackoverflow
Solution 11 - C#Darren KoppView Answer on Stackoverflow
Solution 12 - C#plinthView Answer on Stackoverflow
Solution 13 - C#battlmonstrView Answer on Stackoverflow
Solution 14 - C#coffeeeeeView Answer on Stackoverflow
Solution 15 - C#Grigoris DimitroulakosView Answer on Stackoverflow