Is a Linq Statement Faster Than a 'Foreach' Loop

Is a LINQ statement faster than a 'foreach' loop?

Why should LINQ be faster? It also uses loops internally.

Most of the times, LINQ will be a bit slower because it introduces overhead. Do not use LINQ if you care much about performance. Use LINQ because you want shorter better readable and maintainable code.

Is this really a case when Linq is faster than a Foreach

LINQ will usually be faster when it can take advantage of deferred execution; as it does here.

As you suspected; foreach fully enumerates the collection in your code. Select just builds a query to do that enumeration.

Then when you call Sum, it enumerates the previously generated collection. We have a total of 2 enumerations for foreach and just one for Select, so it is faster (by a factor of 2!)

There are other examples; Take, and First will stop execution early (a foreach can stop early, but most people don't code it that way).

Basically, use foreach when you actually need to enumerate the whole collection for what you are doing, or when you want to enumerate (consume) a LINQ query. Use LINQ when you are running queries and operations where deferred execution will get you a performance benefit. When that query returns a collection, use foreach to iterate over it.

is nested Linq faster than foreach loop?

For Linq-to-objects, code with foreach is always marginally faster that equivalent LINQ call just because at the end LINQ end up with similar foreach after several method calls. For Linq-to-SQL/Linq-to-XML equivalent code with less function calls would be faster too just because you execute less code.

Note that proper matching code for more complex LINQ expressions may not be easy to write (try writing GroupBy yourself correctly) and definitely will not be shorter than LINQ.

Whether this performance different matters for your application - measure yourself against your particular performance goals.

Style of code is strictly personal preference - pick whatever works for you/your team.

LINQ vs foreach vs for performance test results

You never execute the LINQ query, you just create it. You should use ToList or ToArray method to force an iteration, probably you won't get a different result because LINQ uses a foreach loop as well.

Edit: LINQ takes a little bit more time because you are iterating over all of the items. But in your other two loops you are breaking the loop as soon as you find a match. Try using FirstOrDefault instead of Where and you should get the same (or similar) result.

people.FirstOrDefault(p => p.Name == name);

Is LINQ slower than foreach loop for aggregation operations?

It seems it is about what you are iterating. I slightly changed your code. First it is iterating over IEnumerable (which you say linq), and then iterating over List (which you say foreach). I got the same results with you.

Please check the methods withIEnumerable and withList. They do exactly the same thing except that signatures are different. LINQ extension methods gets IEnumerable as parameter.

Edit: Performance between Iterating through IEnumerable<T> and List<T> gives a good explanation why list enumerates faster.

class Program
{
    static void Main(string[] args)
    {
        for (int i = 0; i < 10; i++)
        {
            calculate();
        }

    }

    private static void calculate()
    {
        List<Double> numbers = new List<Double>();
        Double[] sums1 = new Double[1000];
        Double[] sums2 = new Double[1000];

        for (int i = 0; i < 1000; i++)
        {
            numbers.Add(i * i);
        }

        Int64 startTime1 = Stopwatch.GetTimestamp();
        for (int i = 0; i < 1000; i++)
        {
            sums1[i] = withIEnumerable(numbers);
        }
        Int64 endTime1 = Stopwatch.GetTimestamp();

        Int64 startTime2 = Stopwatch.GetTimestamp();
        for (int i = 0; i < 1000; i++)
        {
            sums2[i] = withList(numbers);
        }
        Int64 endTime2 = Stopwatch.GetTimestamp();


        Console.WriteLine("withIEnumerable.    Start = {0}, End = {1}: Diff = {2}", startTime1, endTime1, endTime1 - startTime1);
        Console.WriteLine("withList. Start = {0}, End = {1}: Diff = {2}", startTime2, endTime2, endTime2 - startTime2);
    }

    private static double withIEnumerable(IEnumerable<double> numbers)
    {
        double sum = 0;
        foreach (Double number in numbers)
        {
            sum += number;
        }

        return sum;
    }

    private static double withList(List<double> numbers)
    {
        double sum = 0;
        foreach (Double number in numbers)
        {
            sum += number;
        }

        return sum;
    }
}

Why can LINQ operations be faster than a normal loop?

Undoubtedly you haven't actually performed the query, you've merely defined it. LINQ constructs an expression tree that isn't actually evaluated until you perform an operation that requires that the enumeration be iterated. Try adding a ToList() or Count() operation to the LINQ query to force the query to be evaluated.

Based on your comment I expect this is similar to what you've done. Note: I haven't spent any time figuring out if the query is as efficient as possible; I just want some query to illustrate how the code may be structured.

var dataset = ...

var watch = Stopwatch.StartNew();

var query = dataset.Where( d => dataset.Count( i => i == d ) > 1 );

watch.Stop();  // timer stops here

foreach (var item in query) // query is actually evaluated here
{
   ... print out the item...
}

---

Related Topics