1

Suppose we have a list of students:

var students = new List<Student>(//fill with 5000 students);

We then find the youngest male student from this list:

Method 1:

var youngestMaleStudent = students.Where(s => s.Gender == "male").OrderBy(s => s.Age).First();

Console.WriteLine(youngestMaleStudent.Name);

Method 2:

var maleStudents = students.Where(s => s.Gender == "male").ToList()

var youngestMaleStudent = maleStudents.OrderBy(s => s.Age).First();

Console.WriteLine(youngestMaleStudent.Name);

I would think Method 1 should be more efficient as Method 2 creates a new list and moves everything into it, but presumably, this isn't a huge deal as copying memory is relatively fast? (though 5000 objects may start to weight things down)

But then I think, do they run differently at all performance-wise? How does LINQ process each step in Method 1, does it not need to copy everything into a list of some form in order to then start sorting (ordering) the data?

Akif
  • 7,098
  • 7
  • 27
  • 53
FBryant87
  • 4,273
  • 2
  • 44
  • 72
  • 3
    Did you try it ? – Johan Donne Dec 07 '20 at 17:39
  • Method 2 needs to go through the list at least one more time (compared to 1), which is a waste of processing time – Camilo Terevinto Dec 07 '20 at 17:46
  • @Johan Donne more interested in the underlying why/how than the yes/no – FBryant87 Dec 07 '20 at 17:48
  • `ToList()` causes immediate complete evaluation of the `IEnumerable` returned from `.Where()`. Get rid of that and I'd expect the generated IL (and thus performance )to be identical. – 3Dave Dec 07 '20 at 18:00
  • LINQ still needs to find the males before ordering them though (or order them as it goes, which means more computation per iteration). So is it really faster? – FBryant87 Dec 07 '20 at 18:03
  • @FBryant87 The *only* difference is the `ToList()` call, which is unnecessary and a perf killer. Without `ToList()`, the `.Where()` won't be immediately evaluated. It'll be deferred until the `OrderBy()` call. That's one of the great things about coroutines. – 3Dave Dec 07 '20 at 18:06

2 Answers2

1

Linq deferred execution allows to enqueue, or to chain, differents parts of a query like select, where and order, as for SQL, which is executed when it is used, with a foreach or a ToList() for example.

This is obtained using fluent interface pattern.

What are the benefits of a Deferred Execution in LINQ?

Deferred Execution of LINQ Query (tutorialsteacher.com)

Deferred Vs Immediate Query Execution in LINQ (c-sharpcorner.com)

Therefore method 1 is faster because in method 2 ToList() executes the query and First() executes a new query. Thus this last can be about 2x time at worst without considering underlying caches and optimizations. Because it uses an executed query (ToList()) to do an orderby on it that is a second executed query (First()).

In other words, in method 1, the query is executed only by the First() method call and all previous calls are deferred to prepare the final query for this process like adding parameters in a string (in the case of SQL and it's about the same thing for any other target). But in method 2, the ToList() creates a List<> instance from an executed query that consumes time and memory, and next the First() call do another query on this list, that consumes time and memory again...

So it is important to check in the documentation of every Linq method if it is deferred or not.

Linq can be both a performance and spaghetti code killer as well as a black hole.

  • How is it that Method 1 avoids the additional work specifically? (note no db or SQL here). When it runs through the Where() it can find all males, but surely once it's done it needs to go and order them all. Or does it manage that ordering as it iterates through? – FBryant87 Dec 07 '20 at 17:59
  • 1
    @FBryant87 I'd recommend reading a bit the source code [here](https://referencesource.microsoft.com/#System.Core/System/Linq/Enumerable.cs,e449fbc07f49dc52) - note that it's not trivial code – Camilo Terevinto Dec 07 '20 at 18:02
  • @Olivier Thanks, I understand that the call is deferred, but I still don't see how it's faster as a result in this specific scenario. In Method 1 LINQ still needs to find all the males and order them all - so behind the scene how does it achieve this faster than Method 2? – FBryant87 Dec 07 '20 at 18:12
  • @Camilo I think you're right, only looking at that's going to reveal the answer – FBryant87 Dec 07 '20 at 18:12
  • 1
    @FBryant87 What I wrote is in general and especially for databases. But keep in mind that even for objects, the .NET source code is optimized (probably 1 "loop" for method 1 instead of 2 "loop" for method 2). Only benchmarking will tell you the truth about the data source and the amount of data you use. Searching to avoid unnecessary Linq executions should be automatic as well as refactoring and keeping the code clean. –  Dec 07 '20 at 18:18
0

In method 2 .ToList() convert an IQuryable to IEnumerable and based on that, all data from database fetched and then students.Where(s => s.Gender == "male") condition apply on it in memory.

In method 1 youngestMaleStudent is IQuryable then the query students.Where(s => s.Gender == "male").OrderBy(s => s.Age).First(); processed on database side.

The result is method 1 performed better specially when your data is huge.

Hojat Afsharan
  • 60
  • 8
  • 1
    Nobody ever mentioned a database, LINQ can be used against in-memory objects like in this question. Besides that, method 2 **never** performs better in any possible scenario. – Camilo Terevinto Dec 07 '20 at 17:50
  • 1
    I should edit my answer. I wanted to say method 1 performed better. I edit it now. Thank you. – Hojat Afsharan Dec 07 '20 at 17:53