item.Count() > 0 vs item.Any(): Understanding Performance and Memory Differences in C#

Count() > 0 vs Any()

When writing LINQ queries in C#, we often need to check whether a collection contains at least one element. Two approaches are commonly used:
item.Count() > 0 and item.Any(). Both return the same result, but they work very differently under the hood. Understanding these differences helps us write cleaner, faster, and more memory-efficient code.

Why This Comparison Matters

As our applications grow—especially when dealing with large collections, database queries, or API calls—small inefficiencies add up. Choosing between Count() and Any() is one of those subtle decisions that can impact both performance and memory usage.

How Count() Works

Count() iterates through the entire collection and calculates the total number of elements.

• If the collection is an ICollection, it uses the built-in Count property → efficient.
• If the collection is IEnumerable, it must iterate all elements → potentially expensive.

Implication for Count() > 0

Even if we only need to know whether at least one item exists, Count() may still traverse the entire sequence.

Cost:

• Performance: Could be O(n)
• Memory: Stores and returns an integer, minimal, but traversal cost matters
• Database/API LINQ: Translates to COUNT(*), which scans rows

How Any() Works

Any() is optimized for the “is there at least one element?” scenario.
It stops as soon as it finds the first element.

Cost:

• Performance: O(1) in most cases
• Memory: No extra memory, no counting
• Database/API LINQ: Translates to an EXISTS query → extremely fast

Performance Comparison

Check Type	Count() > 0	Any()
Iteration	May iterate whole collection	Stops after first match
Complexity	O(n)	O(1)
Database Query	COUNT(*)	EXISTS
Large Collections	Slower	Significantly faster
Deferred Execution	Forces full traversal	Short-circuiting

Memory Comparison

Memory usage is generally low for both, but behavior differs:

• Count() may cause full enumeration, increasing processor work and potentially causing unnecessary allocations in complex iterators.
• Any() avoids full traversal, reducing overall memory footprint and CPU time.

When Should We Use Which?

Use Any() when:

• We only need to check existence of elements
• Working with large datasets
• Running LINQ-to-Entities or LINQ-to-SQL queries
• Working with IEnumerable streams

Use Count() when:

• We actually need the total number of elements
• The collection is already an ICollection (like List) **and** we want the count

Example

// Efficient
if (items.Any())
{
    // ...
}

// Inefficient for IEnumerable
if (items.Count() > 0)
{
    // ...
}

Conclusion

Both Count() > 0 and Any() return the same logical result, but they behave very differently. As a best practice, we should always prefer Any() when checking for existence. It is faster, more memory-efficient, and optimizes database and API queries through short-circuit evaluation.

A small choice, but one that makes our code cleaner and our applications faster.