LINQ performance considerations in C Sharp (C#)

Introduction

LINQ helps you work with collections easily, but sometimes it can be slower. Knowing how to use it well keeps your programs fast.

When you want to quickly filter or find items in a list.

When you need to transform data from one form to another.

When you want to write clear and simple code for working with collections.

When you want to avoid writing loops manually.

When you want to combine multiple data operations in one place.

Syntax

C Sharp (C#)

var result = collection.Where(x => x.Property > 10).Select(x => x.OtherProperty);

LINQ queries are often lazy, meaning they run only when you ask for the results.

Using methods like ToList() forces LINQ to run immediately and store results.

Examples

This creates a query to get numbers greater than 5 but does not run it yet.

C Sharp (C#)

var filtered = numbers.Where(n => n > 5);

This runs the query immediately and stores the results in a list.

C Sharp (C#)

var list = numbers.Where(n => n > 5).ToList();

This counts how many numbers are greater than 5 without creating a new collection.

C Sharp (C#)

var count = numbers.Count(n => n > 5);

Sample Program

This program shows that calling Count() and Sum() on the same LINQ query runs the filtering twice. Storing results in a list first avoids repeating work and improves speed.

C Sharp (C#)

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<int> numbers = Enumerable.Range(1, 1000000).ToList();

        // Slow: multiple enumerations
        var filtered = numbers.Where(n => n % 2 == 0);
        int count = filtered.Count();
        long sum = filtered.Select(n => (long)n).Sum();

        Console.WriteLine($"Count: {count}");
        Console.WriteLine($"Sum: {sum}");

        // Faster: cache results to avoid repeating work
        var filteredList = numbers.Where(n => n % 2 == 0).ToList();
        int countCached = filteredList.Count;
        long sumCached = filteredList.Select(n => (long)n).Sum();

        Console.WriteLine($"Count cached: {countCached}");
        Console.WriteLine($"Sum cached: {sumCached}");
    }
}

Important Notes

LINQ queries are lazy and run each time you ask for results, which can cause repeated work.

Use ToList() or ToArray() to store results if you need to use them multiple times.

Avoid complex LINQ queries inside loops to keep performance good.

Summary

LINQ makes working with collections easier but can be slower if used without care.

Remember that LINQ queries run when you ask for results, not when you write them.

Cache query results if you use them more than once to avoid repeating work.