Bits of .NET

⚡ LINQ Performance = Fast Queries

LINQ can be slow. Performance optimization makes LINQ queries fast and efficient.

📝 Optimization Techniques

// 1. Use Any() instead of Count() > 0
bool hasItems = data.Any();  // Good
bool hasItems = data.Count() > 0;  // Bad

// 2. Filter Before Projection
var result = data
    .Where(x => x.IsActive)  // Filter first
    .Select(x => x.Name)      // Then project
    .ToList();

// 3. Use SelectMany instead of Nested Loops
var allItems = data.SelectMany(x => x.Items).ToList();

// 4. Use ToLookup for Grouped Access
var lookup = data.ToLookup(x => x.Category);
var electronics = lookup["Electronics"];

// 5. Use HashSet for Existence Checks
var ids = new HashSet(data.Select(x => x.Id));
bool exists = ids.Contains(id);  // O(1)

// 6. Use Parallel LINQ for Large Datasets
var result = data
    .AsParallel()
    .WithDegreeOfParallelism(Environment.ProcessorCount)
    .Where(x => x.IsActive)
    .Select(x => ProcessItem(x))
    .ToList();

🎯 Advanced Optimization

// 7. Avoid Multiple Enumerations
var data = GetData();
var count = data.Count();  // First enumeration
var first = data.First();  // Second enumeration - Bad!

// Good: Materialize once
var data = GetData().ToList();
var count = data.Count();
var first = data.First();

// 8. Use Compiled Queries (EF Core)
private static readonly Func> GetUserById =
    EF.CompileAsyncQuery((MyContext ctx, int id) =>
        ctx.Users.FirstOrDefault(u => u.Id == id));

// 9. Use Select for Projection
var names = users.Select(u => u.Name);  // Only names
var fullUsers = users.ToList();  // All data - Bad!

// 10. Use Index for Performance
var data = new List { 1, 2, 3, 4, 5 };
var result = data
    .Select((item, index) => new { item, index })
    .Where(x => x.item % 2 == 0)
    .Select(x => $"Item {x.index}: {x.item}")
    .ToList();

// 11. Use Chunk for Batch Processing
var chunks = data.Chunk(100);  // .NET 6+
foreach (var chunk in chunks)
{
    ProcessChunk(chunk);
}

// 12. Use Take/Skip for Pagination
var page = data
    .Skip(pageNumber * pageSize)
    .Take(pageSize)
    .ToList();

💡 LINQ Optimization Tips

• Filter before projection
• Use Any() instead of Count()
• Avoid multiple enumerations
• Use ToLookup for grouping
• Use Parallel LINQ for large data