Difference between LINQ and Lambda Expression internally

Question

5.00/5 (1 vote)

See more:

XML

IList<ResponseDTO> MyList = new List<ResponseDTO>();
var myValue = MyList.Select(T => T.KeyId);
var myValue = from myListValue in MyList
              select myListValue.KeyId;

In the above code the first one is a Lambda Expression & second is LINQ and both give me the same result.

I want to know the internal difference between these two and their performance.

Posted 21-May-12 19:25pm

Rajesh Kariyavula

Updated 21-May-12 19:26pm

v2

Add a Solution

3 solutions

Solution 1

Refer this:

http://stackoverflow.pienose.com/1182922/what-is-the-efficiency-and-performance-of-linq-and-lambda-expression-in-net.html[^]

Posted 21-May-12 19:36pm

sravani.v

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

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

VJ Reddy · Accepted Answer · 2012-05-21T19:56:00

Both syntax compile to the same thing to IL as can be seen from the below code. ResponseDTO is replaced with string and ToUpper method is used to compile the code.

C#

IList<string> MyList = new List<string>();
    var myValue = MyList.Select(T => T.ToUpper());

//IL_0001:  newobj      System.Collections.Generic.List<System.String>..ctor
//IL_0006:  stloc.0
//IL_0007:  ldloc.0
//IL_0008:  ldsfld      UserQuery.CS$<>9__CachedAnonymousMethodDelegate1
//IL_000D:  brtrue.s    IL_0022
//IL_000F:  ldnull
//IL_0010:  ldftn       UserQuery.<Main>b__0
//IL_0016:  newobj      System.Func<System.String,System.String>..ctor
//IL_001B:  stsfld      UserQuery.CS$<>9__CachedAnonymousMethodDelegate1
//IL_0020:  br.s        IL_0022
//IL_0022:  ldsfld      UserQuery.CS$<>9__CachedAnonymousMethodDelegate1
//IL_0027:  call        System.Linq.Enumerable.Select
//IL_002C:  stloc.1
//
//<Main>b__0:
//IL_0000:  ldarg.0
//IL_0001:  callvirt    System.String.ToUpper
//IL_0006:  stloc.0
//IL_0007:  br.s        IL_0009
//IL_0009:  ldloc.0
//IL_000A:  ret

C#

IList<string> MyList = new List<string>();
    var myValue = from myListValue in MyList
                select myListValue.ToUpper();
//IL_0001:  newobj      System.Collections.Generic.List<System.String>..ctor
//IL_0006:  stloc.0
//IL_0007:  ldloc.0
//IL_0008:  ldsfld      UserQuery.CS$<>9__CachedAnonymousMethodDelegate1
//IL_000D:  brtrue.s    IL_0022
//IL_000F:  ldnull
//IL_0010:  ldftn       UserQuery.<Main>b__0
//IL_0016:  newobj      System.Func<System.String,System.String>..ctor
//IL_001B:  stsfld      UserQuery.CS$<>9__CachedAnonymousMethodDelegate1
//IL_0020:  br.s        IL_0022
//IL_0022:  ldsfld      UserQuery.CS$<>9__CachedAnonymousMethodDelegate1
//IL_0027:  call        System.Linq.Enumerable.Select
//IL_002C:  stloc.1
//
//<Main>b__0:
//IL_0000:  ldarg.0
//IL_0001:  callvirt    System.String.ToUpper
//IL_0006:  stloc.0
//IL_0007:  br.s        IL_0009
//IL_0009:  ldloc.0
//IL_000A:  ret

In the second syntax called as query syntax some of the extension methods of IEnumerable are not available.
Each syntax is useful in certain conditions and sometimes both syntax are used in a mix.

A good discussion on this topic is available here
http://stackoverflow.com/questions/214500/which-linq-syntax-do-you-prefer-fluent-or-query-expression[^]

Prasad_Kulkarni · Accepted Answer · 2012-05-21T20:03:00

Linq is always associated with Lambda Expressions.
In .NET 2.0 we have the concept of Annonymous Methods that allows you to write function body inline without the need of writing a delegate function.
Lambda Expression of .NET 3.5 is to consize the concept of Annonymous function writing.
This CP article explains you about: Basics of LINQ & Lamda Expressions[^]

In addition,
You can use Lambda Expressions when you want to create a delegate or an expression tree, basically.
Here are some examples outside LINQ:

The old-style List<T>.ConvertAll/FindAll etc methods
Starting new threads / tasks
Attaching event handlers
Providing an action in unit tests (e.g. "this action should throw an exception")
Providing a value on request for Lazy<T>

Things which are only be achieved by Lambda expression & not by LINQ queries.
There are some LINQ extension methods which do not have counterparts in LINQ query expressions, and will require the use of Lambda Expressions.

A good example is Enumerable.ToLookup[^] - if you want to create an ILookup, you need to use lambdas to generate this.

Difference between LINQ and Lambda Expression internally

3 solutions

Solution 2

Solution 3

Solution 1

Add your solution here

Preview 0