What’s the point of a lambda expression?

by

First: brevity and locality:

Which would you rather write, read and maintain? This:

    var addresses = customers.Select(customer=>customer.Address);

or:

static private Address GetAddress(Customer customer)
{
     return customer.Address;
}

... a thousand lines later ...

    var addresses = customers.Select(GetAddress);

What’s the point of cluttering up your program with hundreds or thousands of four-line functions when you could just put the code you need where you need it as a short expression?

Second: lambdas close over local scopes

Which would you rather read, write and maintain, this:

var currentCity = GetCurrentCity();
var addresses = customers.Where(c=>c.City == currentCity).Select(c=>c.Address);

or:

static private Address GetAddress(Customer customer)
{
     return customer.Address;
}

private class CityGetter
{
    public string currentCity;
    public bool DoesCityMatch(Customer customer)
    {
        return customer.City == this.currentCity;
    }
}

....

var currentCityGetter = new CityGetter();
currentCityGetter.currentCity = GetCurrentCity();
var addresses = customers.Where(currentCityGetter.DoesCityMatch).Select(GetAddress);

All that vexing code is written for you when you use a lambda.

Third: Query comprehensions are rewritten to lambdas for you

When you write:

var addresses = from customer in customers
                where customer.City == currentCity 
                select customer.Address;

it is transformed into the lambda syntax for you. Many people find this syntax pleasant to read, but we need the lambda syntax in order to actually make it work.

Fourth: lambdas are optionally type-inferred

Notice that we don’t have to give the type of “customer” in the query comprehension above, or in the lambda versions, but we do have to give the type of the formal parameter when declaring it as a static method. The compiler is smart about inferring the type of a lambda parameter from context. This makes your code less redundant and more clear.

Fifth: Lambdas can become expression trees

Suppose you want to ask a web server “send me the addresses of the customers that live in the current city.” Do you want to (1) pull down a million customers from the web site and do the filtering on your client machine, or (2) send the web site an object that tells it “the query contains a filter on the current city and then a selection of the address”? Let the server do the work and send you only the result that match.

Expression trees allow the compiler to turn the lambda into code that can be transformed into another query format at runtime and sent to a server for processing. Little helper methods that run on the client do not.

More Related Contents:

  1. Why would you use Expression rather than Func?
  2. delegate keyword vs. lambda notation
  3. Why can’t an anonymous method be assigned to var?
  4. Why must a lambda expression be cast when supplied as a plain Delegate parameter
  5. How do I invoke an extension method using reflection?
  6. Wrapping StopWatch timing with a delegate or lambda?
  7. Uses of Action delegate in C# [closed]
  8. Creating a property setter delegate
  9. Getting all types that implement an interface
  10. Unsubscribe anonymous method in C#
  11. Compiler Ambiguous invocation error – anonymous method and method group with Func or Action
  12. C# Lambda expressions: Why should I use them?
  13. C# Lambda ( => ) [duplicate]
  14. Delegates: Predicate vs. Action vs. Func
  15. How do C# Events work behind the scenes?
  16. Can I specify my explicit type comparator inline?
  17. How do I create an expression tree to represent ‘String.Contains(“term”)’ in C#?
  18. C# 3.0 generic type inference – passing a delegate as a function parameter
  19. Entity Framework Filter “Expression”
  20. lambda expressions in immediate window for VS2015
  21. Expression of type ‘System.Int32’ cannot be used for return type ‘System.Object’
  22. How to correctly unregister an event handler
  23. Peculiar overload resolution with while (true)
  24. Local variable and expression trees
  25. How to cast Expression to Expression
  26. convert this LINQ expression into Lambda
  27. List complex sorting
  28. How can I capture the value of an outer variable inside a lambda expression?
  29. How do I create a delegate for a .NET property?
  30. a constructor as a delegate – is it possible in C#?

Leave a Comment