Comments on: LINQ vs Loop – A performance test

By: Håvard

Håvard — Thu, 24 Mar 2011 11:33:00 +0000

CmdJerry:

Your first source at best misleading, at worst wrong. (Theoretically, one might create a case where LINQ queries iterate across enumerables that themselves iterate the entire result set once for each item, but that's irrelevant to the understanding of LINQ and its behavior.)

Your second source explains the behavior correctly: LINQ queries use deferred execution, which implies that nothing is executed until you iterate the results of your query. Further, iteration with a plain loop will iterate the enumerable once and only once.

Calling ToList() is just the same as writing a loop which adds the items to a list:

var yourQuery = from item in manyItems select item;
// Calling ToList()...
var listOfItems = yourQuery.ToList();
// ... is equivalent to building your own list in a loop
var list = new List();
foreach(var item in yourQuery)
    list.Add(item);

So there is nothing to gain performance-wise by calling ToList() when iterating across the results once. In fact, calling ToList() and then looping will perform worse than just looping. There's nothing magic to it.

I recommend you read up on deferred execution and the yield statement. Charlie Calvert's post on LINQ and deferred execution is a good start.

By: CmdJerry

CmdJerry — Thu, 24 Mar 2011 03:46:38 +0000

The LINQ query object still is used underneath the enumerable object when looping. This means the query is called repeatedly when looping. Take a look at these two articles http://allthingscs.blogspot.com/2011/03/linq-performance.html and http://odetocode.com/code/737.aspx

By: LinqTrialerandHater

LinqTrialerandHater — Fri, 18 Mar 2011 05:14:36 +0000

Bah Linq, ever thought of what your going to do if you wish to port your application to a different language that doesn’t use Lamda expressions or Linq! youre stuffed! there really is no difference between linq and a for loop. If it was faster than a for loop I would think its cool, but its not and it’s also harder to look at, understand and debug. It’s just a bunch a snobs trying to be smarter and cleverer than everyone else, Wow! look at the weird and cryptic linq expression I can write! it’s slower and harder to understand and if I ever want to port my code to objective C++ or PHP or something. I can just sit on it, and go wow, I thought it was cool but its slower and really just microsofts way of keeping you locked into their product! So THERE!

By: Sanjay

Sanjay — Fri, 04 Mar 2011 16:09:01 +0000

My test indicate that it a lot depends on how "random" the data in the ints array is. Adding the following to shuffle data to be < 10 and > 10 for (int j = 0; j < SIZE; j++) {

            if(j%2 == 0)
                ints[j] = 5;

    }

makes LINQ faster than the loop. Then again, I am testing in 2011. So a lot would have changed since this initial post in 2007.

By: Performance Tip: Avoid using Linq Loops « rjchicago

Performance Tip: Avoid using Linq Loops « rjchicago — Thu, 30 Sep 2010 21:12:01 +0000

[...] http://ox.no/posts/linq-vs-loop-a-performance-test [...]

By: funky

funky — Thu, 15 Apr 2010 14:36:25 +0000

Thanks! I was getting 50% of CPU usage by writing file to a Stream, like so:

buffer = formData.Skip(offset).Take(buffer.Length).ToArray();

After reading your comments, I’ve rewritten my code to use loop and now CPU is quiet as ever

By: Ray

Ray — Sat, 12 Sep 2009 04:03:35 +0000

My code for Linq:

for (int t = 0; t < RUNS; ++t) { int[] less = ints.Where(i => i < 10).ToArray(); }

My result: LINQ: 00:00:00.0936002, avg. 00:00:00.0000936 Loop: 00:00:00.1092002, avg. 00:00:00.0001092

By: Eric Kaufman

Eric Kaufman — Fri, 15 May 2009 19:38:48 +0000

Just wanted to add in that with .Net 4.0 they’re upgrading the compiler, and adding parallelism for LINQ queries, which I expect will change things out a lot. For those of you who did hop on the LINQ train, I would imagine that a lot of your queries might just start to work a bit quicker once the new compiler comes out.

http://www.betanews.com/article/Everyone-talk-at-once-NET-40-will-include-Parallel-Extensions/1223931673

By: Brian

Brian — Sat, 09 May 2009 18:29:11 +0000

This function does nothing, and thus benchmarking a compiled version is dangerous (so is benchmarking a debug version, but less so). A compiler will happily say, “This loop does nothing! Let’s skip it!” I’d be hesitant to trust any benchmarks that are not in use on production code…though they’re a nice tool for developers of compilers to use to check if their optimizations are working.

By: JS

JS — Wed, 25 Feb 2009 21:08:27 +0000

If you run the compiled verision of the application (.exe or .dll), LINQ actually runs faster

running out of VS is not a valid test and should not be compared.