Improving performance with LINQ in C# is essential, especially when working with large datasets. LINQ provides a powerful and expressive way to query data, but it can introduce performance overhead if not used efficiently. Below are some tips and tricks to improve LINQ performance, along with sample code:

1. Avoid repeated Enumeration

When you execute a LINQ query, it can be enumerated multiple times, leading to unnecessary performance hits.

You can improve performance by materializing the result of a query (e.g., using ToList(), ToArray(), or ToDictionary()).

var data = GetData(); // Some large collection

// Not good: Repeatedly enumerating the sequence
var count = data.Where(x => x.IsActive).Count();
var sum = data.Where(x => x.IsActive).Sum(x => x.Value);

// Good: Materializing the result to avoid repeated enumeration
var activeData = data.Where(x => x.IsActive).ToList();
var count = activeData.Count;
var sum = activeData.Sum(x => x.Value);

2. Use Any()  instead of Count() > 0

If you're only checking whether a collection contains any elements, using Any() is faster than Count() > 0.

Any() stops as soon as it finds the first matching element, whereas Count() counts all elements before returning a result.

// Not good: Counting all elements
if (data.Where(x => x.IsActive).Count() > 0) { ... }

// Good: Checking for any element
if (data.Where(x => x.IsActive).Any()) { ... }

3. Use FirstOrDefault() and SingleOrDefault()

When you expect only one element or none, use FirstOrDefault() or SingleOrDefault() instead of Where() combined with First() or Single().

These methods are optimized for single element retrieval.

// Not good: Using Where with First
var item = data.Where(x => x.Id == 1).FirstOrDefault();

// Good: Using FirstOrDefault directly
var item = data.FirstOrDefault(x => x.Id == 1);

4. Use OrderBy and ThenBy efficiently

If you need to sort data, make sure that you're sorting only what is necessary, as sorting can be an expensive operation. Additionally, try to minimize the number of sorting operations.

// Not good: Multiple OrderBy statements
var sortedData = data.OrderBy(x => x.Age).OrderBy(x => x.Name);

// Good: Using OrderBy and ThenBy together
var sortedData = data.OrderBy(x => x.Age).ThenBy(x => x.Name);

5. Optimize GroupBy

The GroupBy operator can be expensive, especially if you're grouping large collections. If you need to perform a GroupBy but only need to count or get the First/Last element in each group, avoid creating the entire group and just perform a more efficient aggregation.

// Not good: GroupBy followed by a complex operation
var grouped = data.GroupBy(x => x.Category)
                  .Select(g => new { Category = g.Key, Count = g.Count() })
                  .ToList();

// Good: Perform aggregation more directly
var counts = data.GroupBy(x => x.Category)
                 .Select(g => new { Category = g.Key, Count = g.Count() })
                 .ToDictionary(g => g.Category, g => g.Count);

6. Prefer IEnumerable<T> over List<T> when possible

LINQ queries work best with IEnumerable<T> because it represents a lazy sequence.

Converting it to a List<T> immediately could result in unnecessary memory usage if not required.

// Not good: Convert to List too early
var result = data.Where(x => x.IsActive).ToList();

// Good: Keep it as IEnumerable until it's really needed
IEnumerable<int> result = data.Where(x => x.IsActive);

 

Hoping with these tips, you can significantly improve the performance of your LINQ queries in C#.

References:

https://www.bytehide.com/blog/linq-performance-optimization-csharp

Image source: https://www.freepik.com/free-photo/top-view-laptop-table-glowing-screen-dark_160644251.htm