“Nested foreach” vs “lambda/linq query” performance(LINQ-to-Objects) [closed]

by

Write the clearest code you can, and then benchmark and profile to discover any performance problems. If you do have performance problems, you can experiment with different code to work out whether it’s faster or not (measuring all the time with as realistic data as possible) and then make a judgement call as to whether the improvement in performance is worth the readability hit.

A direct foreach approach will be faster than LINQ in many cases. For example, consider:

var query = from element in list
            where element.X > 2
            where element.Y < 2
            select element.X + element.Y;

foreach (var value in query)
{
    Console.WriteLine(value);
}

Now there are two where clauses and a select clause, so every eventual item has to pass through three iterators. (Obviously the two where clauses could be combined in this case, but I’m making a general point.)

Now compare it with the direct code:

foreach (var element in list)
{
    if (element.X > 2 && element.Y < 2)
    {
        Console.WriteLine(element.X + element.Y);
    }
}

That will run faster, because it has fewer hoops to run through. Chances are that the console output will dwarf the iterator cost though, and I’d certainly prefer the LINQ query.

EDIT: To answer about “nested foreach” loops… typically those are represented with SelectMany or a second from clause:

var query = from item in firstSequence
            from nestedItem in item.NestedItems
            select item.BaseCount + nestedItem.NestedCount;

Here we’re only adding a single extra iterator, because we’d already be using an extra iterator per item in the first sequence due to the nested foreach loop. There’s still a bit of overhead, including the overhead of doing the projection in a delegate instead of “inline” (something I didn’t mention before) but it still won’t be very different to the nested-foreach performance.

This is not to say you can’t shoot yourself in the foot with LINQ, of course. You can write stupendously inefficient queries if you don’t engage your brain first – but that’s far from unique to LINQ…

More Related Contents:

  1. Is there a reason for C#’s reuse of the variable in a foreach?
  2. Sorting a list using Lambda/Linq to objects
  3. LINQ identity function
  4. Lambda Expression using Foreach Clause [duplicate]
  5. Lambda Expression for join
  6. Getting all types that implement an interface
  7. How do you get the index of the current iteration of a foreach loop?
  8. C# Lambda expressions: Why should I use them?
  9. C# Lambda ( => ) [duplicate]
  10. Visual Studio debugging “quick watch” tool and lambda expressions
  11. LINQ to SQL and a running total on ordered results
  12. Can I specify my explicit type comparator inline?
  13. Wrapping StopWatch timing with a delegate or lambda?
  14. How do I create an expression tree to represent ‘String.Contains(“term”)’ in C#?
  15. Entity Framework Filter “Expression”
  16. lambda expressions in immediate window for VS2015
  17. Proper Currying in C#
  18. Expression of type ‘System.Int32’ cannot be used for return type ‘System.Object’
  19. Peculiar overload resolution with while (true)
  20. Local variable and expression trees
  21. How to cast Expression to Expression
  22. Why do some C# lambda expressions compile to static methods?
  23. convert this LINQ expression into Lambda
  24. List complex sorting
  25. How can I capture the value of an outer variable inside a lambda expression?
  26. Code equivalent to the ‘let’ keyword in chained LINQ extension method calls
  27. Is there a way to specify an “empty” C# lambda expression?
  28. Starting a new thread in a foreach loop
  29. Getting names of local variables (and parameters) at run-time through lambda expressions
  30. How do I copy items from list to list without foreach?

Leave a Comment