LINQ Mastery

Min, Max, Average: Statistical operations

1 Views Updated 5/4/2026

Analytics in LINQ

Finding the extremes and the middle ground in your data streams.

1. Min and Max

Returns the smallest or largest value in a sequence. You can also pass a selector: users.Max(u => u.LastLoginDate) to find the most recent login without sorting the whole list. This is an O(N) operation and is very efficient.

2. Average

Calculates the mean of a sequence. **Warning:** If the sequence is empty, Average() will throw an InvalidOperationException. **Architect Tip:** Always check .Any() before calling .Average(), or use null-coalescing on the result to provide a default value of 0.


// Safe way to get average
var avg = orders.Any() ? orders.Average(o => o.Total) : 0;
    

3. Architect Insight

Q: "How do I handle Min/Max on empty sequences?"

Architect Answer: "Use the **DefaultIfEmpty()** method. myList.DefaultIfEmpty(0).Max(). This ensures that if the list is empty, it 'injects' a 0 into the stream, so the Max function has something to return instead of crashing your production server."

LINQ Mastery
General
Introduction to LINQ Mastery
1. Core Foundations
LINQ Fundamentals: Why LINQ? IQueryable vs IEnumerable: The Architect's choice Expression Trees: The power behind LINQ providers Method Syntax vs Query Syntax: Trade-offs
2. Filtering & Transformation
Where & Select: The bread and butter SelectMany: Flattening complex hierarchies OfType vs Cast: Handling heterogeneous collections Distinct & DistinctBy: Mastering unique sets
3. Aggregation & Quantifiers
Any, All, Contains: The boolean quantifiers Count, LongCount, Sum: Basic aggregations Min, Max, Average: Statistical operations Aggregate: The 'Fold' function of .NET
4. Ordering & Partitioning
OrderBy & OrderByDescending: Sorting data ThenBy: Multi-level sorting Take & Skip: Pagination strategies TakeWhile & SkipWhile: Dynamic partitioning
5. Sets & Lookups
Union, Intersect, Except: Set theory in C# Zip: Combining two streams ToDictionary vs ToLookup: One-to-One vs One-to-Many Chunk: Slicing data for batch processing
6. Join & Grouping
Inner Join: The standard match GroupJoin: Creating hierarchical results GroupBy: The SQL counterpart in LINQ Left Outer Join: The manual workaround in LINQ
7. Advanced Providers & Parallelism
PLINQ (Parallel LINQ): Speeding up CPU-bound queries AsParallel vs AsSequential: When to switch LINQ to XML: Processing documents with ease Custom LINQ Providers: How to build your own 'Queryable'
8. Real-world Performance & Patterns
Memory Leaks in LINQ: Capturing variables and closures Architect Case Study: Optimizing a multi-join dashboard query