LINQ Mastery

Count, LongCount, Sum: Basic aggregations

2 Views Updated 5/6/2026

Counting and Summing

Basic math in LINQ. These methods collapse a sequence of data into a single numeric value.

1. Count vs LongCount

Count() returns an int (max 2.1 billion). If you are processing truly 'Big Data' (like a logging table or financial transactions), use LongCount() which returns a long (64-bit integer).

2. The 'Sum' Method

Calculates the total of a numeric sequence. **Architect Note:** Sum will throw an exception if the sequence contains null values (for Nullable types), unless you handle them. For decimal?, Sum returns 0 if the list is empty, which is usually exactly what you want for financial reports.

3. Architect Insight

Q: "Is Count() on IQueryable fast?"

Architect Answer: "Yes. EF Core translates .Count() into a SELECT COUNT(*) SQL query. This is extremely fast because the database doesn't have to send any row data back—it just sends the single number. Always do your counting on the database sideWhenever possible."

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