LINQ – Lambda Expression vs Query Expression

As you’re probably aware of already, LINQ comes in two flavours – using Lambda expressions and using SQL-like query expressions:

Func<int, bool> isEven = i => i % 2 == 0;
int[] ints = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
// using Query expression
var evensQuery = from i in ints where isEven(i) select i;
// using Lambda expression
var evensLambda = ints.Where(isEven);

Both yields the same result because query expressions are translated into their lambda expressions before they’re compiled. So performance-wise, there’s no difference whatsoever between the two.

Which one you should use is mostly personal preference, many people prefer lambda expressions because they’re shorter and more concise, but personally I prefer the query syntax having worked extensively with SQL. With that said, it’s important to bear in mind that there are situations where one will be better suited than the other.

Joins

Here’s an example of how you can join sequence together using Lambda and query expressions:

class Person
{
public string Name { get; set; }
}
class Pet
{
public string Name { get; set; }
public Person Owner { get; set; }
}
void Main()
{
var magnus = new Person { Name = "Hedlund, Magnus" };
var terry = new Person { Name = "Adams, Terry" };
var charlotte = new Person { Name = "Weiss, Charlotte" };
var barley = new Pet { Name = "Barley", Owner = terry };
var boots = new Pet { Name = "Boots", Owner = terry };
var whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
var daisy = new Pet { Name = "Daisy", Owner = magnus };
var people = new List { magnus, terry, charlotte };
var pets = new List { barley, boots, whiskers, daisy };
// using lambda expression
var lambda = people.Join(pets, // outer sequence
person => person, // inner sequence key
pet => pet.Owner, // outer sequence key
(person, pet) =>
new { OwnerName = person.Name, Pet = pet.Name });
// using query expression
var query = from person in people
join pet in pets on person equals pet.Owner
select new { OwnerName = person.Name, Pet = pet.Name };
}

Again, both yields the same result and there is no performance penalties associated with either, but it’s easy to see why query syntax is far more readable and expressive of your intent here than the lambda expression!

Lambda-Only Functions

There are a number of methods that are only available with the Lambda expression, Single(), Take(), Skip(), First() just to name a few. Although you can mix and match the two by calling the Lambda-only methods at the end of the query:

// mix and match query and Lambda syntax
var query = (from person in people
join pet in pets on person equals pet.Owner
select new { OwnerName = person.Name, Pet = pet.Name }).Skip(1).Take(2);

As this reduces the readability of your code, it’s generally better to first assign the result of a query expression to a variable and then use Lambda expression using that variable:

var query = from person in people
join pet in pets on person equals pet.Owner
select new { OwnerName = person.Name, Pet = pet.Name };
var result = query.Skip(1).Take(2);

Both versions returns the same result because of delayed execution (the query is not executed against the underlying list until you try to iterate through the result variable). Also, because query expressions are translated to Lambda expressions first before being compiled there will not be performance penalties either. BUT, if you don’t want delayed execution, or need to use one of the aggregate functions such as Average() or Sum(), for example, you should be aware of the possibility of the underlying sequence being modified between the assignments to query and result. In this case,I’d argue it’s best to use Lambda expressions to start with or add the Lambda-only methods to the query expression.

As per your question what you asking is that difference between LINQ and Lambda expression. R8 ?

Their is no such any differnce in between this two, they are two different thing.

Lambda is Expression where as LINQ is query statement that use lambda expression to create query from programming.

Don't be confuse !!

Lambda is a expression which is introduced in .net framework 3.0.

Note :- Lambda (=>) introduced because to create anonymous method.

So if you have any idea about aonymous function then you might get clear picture about this.

To know more about anonymous method read from bellow.

https://msdn.microsoft.com/en-us/library/bb397687.aspx

This lambda expression is used to build Linq statements.

So their is no any difference, but to build up LINQ we use Lambda expression.

For eg:- List lststd=new Lst;

var TotalStudent= lststd.Select(x => x.CurrencyID);

To know more about LINQ read from bellow:-

https://msdn.microsoft.com/en-us/library/bb397933.aspx

Hope this help you.

Any doubt ask here.

Mark as answer if it helpfull.

3 Replies

Know the answer? Post it — somebody with the same question will find it here.

Ananth G10y ago
Accepted answer
LINQ – Lambda Expression vs Query Expression

As you’re probably aware of already, LINQ comes in two flavours – using Lambda expressions and using SQL-like query expressions:
Func<int, bool> isEven = i => i % 2 == 0;
int[] ints = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

// using Query expression
var evensQuery = from i in ints where isEven(i) select i;
// using Lambda expression
var evensLambda = ints.Where(isEven);
Both yields the same result because query expressions are translated into their lambda expressions before they’re compiled. So performance-wise, there’s no difference whatsoever between the two.
Which one you should use is mostly personal preference, many people prefer lambda expressions because they’re shorter and more concise, but personally I prefer the query syntax having worked extensively with SQL. With that said, it’s important to bear in mind that there are situations where one will be better suited than the other.
Joins
Here’s an example of how you can join sequence together using Lambda and query expressions:
class Person
{
    public string Name { get; set; }
}
class Pet
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}

void Main()
{
    var magnus = new Person { Name = "Hedlund, Magnus" };
    var terry = new Person { Name = "Adams, Terry" };
    var charlotte = new Person { Name = "Weiss, Charlotte" };
    var barley = new Pet { Name = "Barley", Owner = terry };
    var boots = new Pet { Name = "Boots", Owner = terry };
    var whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
    var daisy = new Pet { Name = "Daisy", Owner = magnus };
    var people = new List { magnus, terry, charlotte };
    var pets = new List { barley, boots, whiskers, daisy };

    // using lambda expression
    var lambda = people.Join(pets,              // outer sequence
                             person => person,  // inner sequence key
                             pet => pet.Owner,  // outer sequence key
                             (person, pet) =>
                                 new { OwnerName = person.Name, Pet = pet.Name });

    // using query expression
    var query = from person in people
                join pet in pets on person equals pet.Owner
                select new { OwnerName = person.Name, Pet = pet.Name };
}
Again, both yields the same result and there is no performance penalties associated with either, but it’s easy to see why query syntax is far more readable and expressive of your intent here than the lambda expression!
Lambda-Only Functions
There are a number of methods that are only available with the Lambda expression, Single(), Take(), Skip(), First() just to name a few. Although you can mix and match the two by calling the Lambda-only methods at the end of the query:
// mix and match query and Lambda syntax
var query = (from person in people
             join pet in pets on person equals pet.Owner
             select new { OwnerName = person.Name, Pet = pet.Name }).Skip(1).Take(2);
As this reduces the readability of your code, it’s generally better to first assign the result of a query expression to a variable and then use Lambda expression using that variable:
var query = from person in people
            join pet in pets on person equals pet.Owner
            select new { OwnerName = person.Name, Pet = pet.Name };

var result = query.Skip(1).Take(2);
  Both versions returns the same result because of delayed execution (the query is not executed against the underlying list until you try to iterate through the result variable). Also, because query expressions are translated to Lambda expressions first before being compiled there will not be performance penalties either. BUT, if you don’t want delayed execution, or need to use one of the aggregate functions such as Average() or Sum(), for example, you should be aware of the possibility of the underlying sequence being modified between the assignments to query and result. In this case,I’d argue it’s best to use Lambda expressions to start with or add the Lambda-only methods to the query expression.
0
Surya Kant10y ago
As per your question what you asking is that difference between LINQ and Lambda expression. R8 ?
Their is no such any differnce in between this two, they are two different thing.
Lambda is Expression where as LINQ is query statement that use lambda expression to create query from programming.
Don't be confuse !!
Lambda is a expression which is introduced in .net framework 3.0.
Note :- Lambda (=>) introduced because to create anonymous method.
So if you have any idea about aonymous function then you might get clear picture about this.
To know more about anonymous method read from bellow.
https://msdn.microsoft.com/en-us/library/bb397687.aspx
This lambda expression is used to build Linq statements.
So their is no any difference, but to build up LINQ we use Lambda expression.
For eg:- List lststd=new Lst;
var TotalStudent= lststd.Select(x => x.CurrencyID);
To know more about LINQ read from bellow:-
https://msdn.microsoft.com/en-us/library/bb397933.aspx
Hope this help you.
Any doubt ask here.
Mark as answer if it helpfull.
0
Midhun Tp10y ago
Hi,

Please follow below links. The linq queries are converted to lambda expression before compilation -

http://stackoverflow.com/questions/3914611/comparision-linq-vs-lambda-expression

http://theburningmonk.com/2010/02/linq-lambda-expression-vs-query-expression/

https://blogs.msdn.microsoft.com/wriju/2006/12/06/linq-query-vs-lambda-expression/
+1

Linq queries and lambda expressions

LINQ – Lambda Expression vs Query Expression

Joins

Lambda-Only Functions