csharp-linq

name	csharp-linq
user-invocable	false
description	Use when lINQ (Language Integrated Query) with query and method syntax, deferred execution, expression trees, and performance optimization.
allowed-tools	["Read","Write","Edit","Grep","Glob","Bash"]

C# LINQ

LINQ (Language Integrated Query) provides a consistent query experience across different data sources including collections, databases, XML, and more. It combines the power of SQL-like queries with C# type safety and IntelliSense support, enabling expressive and maintainable data manipulation code.

Query Syntax

Query syntax provides SQL-like syntax for querying data sources, compiled to method calls at compile time.

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

public class QuerySyntaxExamples
{
    public record Person(string Name, int Age, string City);

    // Basic query
    public IEnumerable<Person> BasicQuery(List<Person> people)
    {
        var query = from p in people
                    where p.Age >= 18
                    select p;

        return query;
    }

    // Query with multiple conditions
    public IEnumerable<Person> MultipleConditions(List<Person> people)
    {
        var query = from p in people
                    where p.Age >= 18 && p.City == "Seattle"
                    orderby p.Name
                    select p;

        return query;
    }

    // Projection with select
    public IEnumerable<string> ProjectNames(List<Person> people)
    {
        var query = from p in people
                    where p.Age >= 21
                    select p.Name;

        return query;
    }

    // Anonymous types
    public IEnumerable<object> AnonymousProjection(List<Person> people)
    {
        var query = from p in people
                    select new
                    {
                        p.Name,
                        p.Age,
                        IsAdult = p.Age >= 18
                    };

        return query;
    }

    // Grouping
    public IEnumerable<IGrouping<string, Person>> GroupByCity(
        List<Person> people)
    {
        var query = from p in people
                    group p by p.City;

        return query;
    }

    // Group with projection
    public IEnumerable<object> GroupWithProjection(List<Person> people)
    {
        var query = from p in people
                    group p by p.City into cityGroup
                    select new
                    {
                        City = cityGroup.Key,
                        Count = cityGroup.Count(),
                        AverageAge = cityGroup.Average(p => p.Age)
                    };

        return query;
    }

    // Join
    public record Order(int Id, string PersonName, decimal Amount);

    public IEnumerable<object> JoinExample(
        List<Person> people,
        List<Order> orders)
    {
        var query = from p in people
                    join o in orders on p.Name equals o.PersonName
                    select new
                    {
                        p.Name,
                        p.Age,
                        OrderAmount = o.Amount
                    };

        return query;
    }

    // Left join
    public IEnumerable<object> LeftJoin(
        List<Person> people,
        List<Order> orders)
    {
        var query = from p in people
                    join o in orders on p.Name equals o.PersonName
                    into personOrders
                    from po in personOrders.DefaultIfEmpty()
                    select new
                    {
                        p.Name,
                        OrderAmount = po?.Amount ?? 0
                    };

        return query;
    }
}

Method Syntax

Method syntax uses extension methods for querying, providing more flexibility and access to all LINQ operators.

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

public class MethodSyntaxExamples
{
    public record Product(string Name, decimal Price, string Category);

    // Filtering
    public IEnumerable<Product> FilterProducts(List<Product> products)
    {
        return products
            .Where(p => p.Price > 100)
            .Where(p => p.Category == "Electronics");
    }

    // Ordering
    public IEnumerable<Product> OrderProducts(List<Product> products)
    {
        return products
            .OrderBy(p => p.Category)
            .ThenByDescending(p => p.Price);
    }

    // Projection
    public IEnumerable<string> ProjectNames(List<Product> products)
    {
        return products
            .Select(p => p.Name.ToUpper());
    }

    // SelectMany (flatten)
    public IEnumerable<int> FlattenLists()
    {
        var lists = new List<List<int>>
        {
            new List<int> { 1, 2, 3 },
             List<> { ,  },
             List<> { , , ,  }
        };

         lists.SelectMany(list => list);
    }

    
     IEnumerable<IGrouping<, Product>> GroupByCategory(
        List<Product> products)
    {
         products.GroupBy(p => p.Category);
    }

    
    
    {
         total = products.Sum(p => p.Price);
         average = products.Average(p => p.Price);
         max = products.Max(p => p.Price);
         min = products.Min(p => p.Price);
         count = products.Count();
         expensiveCount = products.Count(p => p.Price > );
    }

    
    
    {
         hasExpensive = products.Any(p => p.Price > );
         allAffordable = products.All(p => p.Price < );
         hasElectronics = products.Any(p =>
            p.Category == );
    }

    
    
    {
         products
            .OrderBy(p => p.Name)
            .Skip((page - ) * pageSize)
            .Take(pageSize);
    }

    
    
    {
         products
            .Select(p => p.Category)
            .Distinct();
    }

    
    
    {
         union = products1.Union(products2);
         intersect = products1.Intersect(products2);
         except = products1.Except(products2);
    }
}

Deferred Execution

LINQ queries use deferred execution, meaning the query executes when enumerated, not when defined.

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

public class DeferredExecutionExamples
{
    // Deferred execution demonstration
    public void DeferredExecutionDemo()
    {
        var numbers = new List<int> { 1, 2, 3, 4, 5 };

        // Query defined but not executed
        var query = numbers.Where(n => n > 2);

        Console.WriteLine("Before modification:");
        foreach (var n in query)  // Executes here
        {
            Console.WriteLine(n);  // 3, 4, 5
        }

        // Modify source
        numbers.Add(6);
        numbers.Add(7);

        Console.WriteLine("After modification:");
        foreach (var n in query)  // Executes again with new data
        {
            Console.WriteLine(n);  // 3, 4, 5, 6, 7
        }
    }

    // Immediate execution with ToList
    public void ImmediateExecution()
    {
        var numbers = new List<int> { 1, 2, 3, ,  };

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

        numbers.Add();
        numbers.Add();

        
         ( n  list)
        {
            Console.WriteLine(n);
        }
    }

    
    
    {
         numbers =  List<> { , , , ,  };

        
         array = numbers.Where(n => n > ).ToArray();
         dict = numbers.ToDictionary(n => n, n => n * );
         hashSet = numbers.ToHashSet();
         lookup = numbers.ToLookup(n => n % );

        
         count = numbers.Count(n => n > );
         sum = numbers.Sum();
         max = numbers.Max();
         any = numbers.Any(n => n > );
    }

    
    
    {
         numbers = GetNumbers();  

        
         count = numbers.Count();
         sum = numbers.Sum();

        
         list = numbers.ToList();
        count = list.Count;
        sum = list.Sum();
    }

    
    {
        Console.WriteLine();
         ( i = ; i <= ; i++)
        {
              i;
        }
    }
}

Complex Queries

Combining multiple LINQ operations for complex data transformations.

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

public class ComplexQueries
{
    public record Student(string Name, int Grade, string Subject,
                          int Score);
    public record Course(string Subject, string Teacher, int Credits);

    // Complex filtering and projection
    public IEnumerable<object> StudentReport(
        List<Student> students,
        List<Course> courses)
    {
        return students
            .Where(s => s.Grade >= 10)
            .GroupBy(s => new { s.Name, s.Grade })
            .Select(g => new
            {
                g.Key.Name,
                g.Key.Grade,
                Subjects = g.Select(s => s.Subject).Distinct(),
                AverageScore = g.Average(s => s.Score),
                TotalCredits = g.Join(
                    courses,
                    s => s.Subject,
                    c => c.Subject,
                    (s, c) => c.Credits
                ).Sum()
            })
            .OrderByDescending(s => s.AverageScore);
    }

    // Nested queries
    public IEnumerable<object> TopStudentsBySubject(
        List<Student> students)
    {
        return students
            .GroupBy(s => s.Subject)
            .Select(g => new
            {
                Subject = g.Key,
                TopStudent = g
                    .OrderByDescending(s => s.Score)
                    .Select(s =>  { s.Name, s.Score })
                    .FirstOrDefault(),
                ClassAverage = g.Average(s => s.Score)
            });
    }

    
    
    {
         students
            .OrderBy(s => s.Name)
            .ThenBy(s => s.Subject)
            .Select((s, index) => 
            {
                s.Name,
                s.Subject,
                s.Score,
                RunningTotal = students
                    .Take(index + )
                    .Sum(x => x.Score)
            });
    }

    
    ;

    
    {
         categories
            .Where(c => c.Parent == )
            .Select(parent => 
            {
                parent.Name,
                Children = categories
                    .Where(c => c.Parent == parent.Name)
                    .Select(child => 
                    {
                        child.Name,
                        Grandchildren = categories
                            .Where(gc => gc.Parent == child.Name)
                    })
            });
    }
}

Performance Optimization

Understanding LINQ performance characteristics and optimization techniques.

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

public class PerformanceOptimization
{
    // Use Count property instead of Count() method
    public void CountOptimization(List<int> numbers)
    {
        // Slow: iterates entire collection
        int count1 = numbers.Where(n => n > 0).Count();

        // Fast: uses Count property if available
        int count2 = numbers.Count;

        // Use Any() instead of Count() for existence check
        bool hasItems = numbers.Any();  // Fast
        bool hasItems2 = numbers.Count() > 0;  // Slow
    }

    // Avoid multiple enumerations
    public void AvoidMultipleEnumerations()
    {
        var query = GetExpensiveQuery();

        // Bad: enumerates multiple times
        int count = query.Count();
        int sum = query.Sum();
        var first = query.First();

        // Good: enumerate once
        var list = query.ToList();
        count = list.Count;
        sum = list.Sum();
        first = list.First();
    }

    // Use Where before Select
    public IEnumerable<string> FilterBeforeProject(List<int> numbers)
    {
        // Good: filter first (fewer items to project)
         numbers
            .Where(n => n > )
            .Select(n => n.ToString());

        
        
        
        
    }

    
     ? FindFirst(List<> numbers)
    {
        
         numbers.FirstOrDefault(n => n > );

        
        
    }

    
    
    {
        
         numbers
            .OrderByDescending(n => n)
            .Take();

        
    }

    
    
    {
         numbers
            .AsParallel()
            .Where(n => ExpensiveOperation(n))
            .Select(n => n * );
    }

    
    {
         Enumerable.Range(, )
            .Where(n => n %  == );
    }

    
    {
        System.Threading.Thread.Sleep();
         n > ;
    }
}

LINQ to Objects vs LINQ to SQL

Understanding differences between in-memory and database queries.

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

public class LinqProviders
{
    public record Customer(int Id, string Name, string City);

    // LINQ to Objects (in-memory)
    public void LinqToObjects(List<Customer> customers)
    {
        // Executes in memory
        var query = customers
            .Where(c => c.City == "Seattle")
            .OrderBy(c => c.Name)
            .Select(c => new { c.Name, c.City });

        // Can use any C# method
        var withMethods = customers
            .Where(c => IsValidCity(c.City))
            .ToList();
    }

    // LINQ to SQL (database)
    public void LinqToSQL()
    {
        // In real application, this would be DbContext
        // var query = dbContext.Customers
        //     .Where(c => c.City == "Seattle")  // Translates to SQL
        //     .OrderBy(c => c.Name)
        //     .Select(c => new { c.Name, c.City });

        // Can't use arbitrary C# methods in SQL query
        // This would throw runtime error:
        // .Where(c => IsValidCity(c.City))

        // Use AsEnumerable() to switch to LINQ to Objects
        // var mixed = dbContext.Customers
        //     .Where(c => c.City == "Seattle")  // SQL
        
        
    }

    
    {
         !.IsNullOrEmpty(city) && city.Length > ;
    }
}

Expression Trees

Understanding expression trees for advanced LINQ scenarios.

using System;
using System.Linq.Expressions;

public class ExpressionTreeExamples
{
    // Building expression trees
    public void BuildExpressionTree()
    {
        // Manual expression tree
        ParameterExpression param = Expression.Parameter(typeof(int), "x");
        BinaryExpression body = Expression.Add(
            param,
            Expression.Constant(5)
        );
        Expression<Func<int, int>> expr =
            Expression.Lambda<Func<int, int>>(body, param);

        // Compile and execute
        Func<int, int> func = expr.Compile();
        int result = func(10);  // 15
    }

    // From lambda to expression
    public void LambdaToExpression()
    {
        // Expression tree from lambda
        Expression<Func<int, bool>> expr = x => x > 5;

        // Compile to delegate
        Func<int, bool> func = expr.Compile();
        bool result = func(10);  // true
    }

    // Analyzing expressions
    public void AnalyzeExpression()
    {
        Expression<Func<int, >> expr = x => x > ;

        
         lambda = (LambdaExpression)expr;
         body = (BinaryExpression)lambda.Body;
         left = (ParameterExpression)body.Left;
         right = (ConstantExpression)body.Right;

        Console.WriteLine();
        Console.WriteLine();
        Console.WriteLine();
    }

    
    
    {
        ParameterExpression param = Expression.Parameter((T), );
        MemberExpression property = Expression.Property(param,
                                                        propertyName);
        ConstantExpression constant = Expression.Constant();
        BinaryExpression equal = Expression.Equal(property, constant);

         Expression.Lambda<Func<T, >>(equal, param);
    }
}

Best Practices

1. Use method syntax for complex queries with multiple operations
2. Use query syntax for queries that look more like SQL
3. Call ToList() or ToArray() when you need to enumerate multiple times
4. Use Any() instead of Count() > 0 for existence checks
5. Filter with Where() before projecting with Select()
6. Use FirstOrDefault() instead of Where().First() when finding single item
7. Avoid Select() when you don't need to transform the data
8. Use AsParallel() only for CPU-intensive operations on large datasets
9. Be aware of deferred execution and when queries actually execute
10. Consider expression tree compilation cost for frequently-used queries

Common Pitfalls

1. Multiple enumeration of IEnumerable causing performance issues
2. Using LINQ on database queries without understanding SQL translation
3. Calling ToList() too early, losing deferred execution benefits
4. Using Count() method instead of Count property on collections
5. Not disposing IEnumerable from database queries, leaking connections
6. Using LINQ for simple loops where foreach would be clearer
7. Excessive AsParallel() causing overhead instead of speedup
8. Capturing variables in lambda expressions causing unintended closures
9. Using Select() where SelectMany() is needed for flattening
10. Not understanding operator precedence in complex query expressions

When to Use LINQ

Use LINQ when you need:

• Querying collections, databases, XML, or other data sources uniformly
• Expressive data transformation and filtering operations
• Type-safe queries with compile-time checking and IntelliSense
• Functional programming patterns for data manipulation
• Complex grouping, joining, and aggregation operations
• Declarative code that expresses intent clearly
• Integration with Entity Framework or other ORMs
• Composition of queries from reusable components
• Parallel processing of large datasets with PLINQ
• Consistent API across different data sources

Resources

• LINQ Documentation
• 101 LINQ Samples
• LINQ Performance Tips
• Expression Trees