IEnumerable<T>.Count() vs List<T>.Count with Entity Framework
entity-framework, extension-methods, linq
Solution
`Enumerable.Count<T>` (the extension method for `IEnumerable<T>`) just calls `Count` if the underlying type is an `ICollection<T>`, so for `List<T>` there is no difference.
`Queryable.Count<T>` (the extension method for `IQueryable<T>`) will use the underlying query provider, which in many cases will push the count down to the actual SQL, which will perform faster than counting the objects in memory.
If a filter is applied (e.g. `Count(i => i.Name = "John")`) or if the underlying type is not an `ICollection<T>`, the collection is enumerated to compute the count.
is one more preferred than the other?
I generally prefer to use `Count()` since 1) it's more portable (the underlying type can be anything that implements `IEnumerable<T>` or `IQueryable<T>`) and 2) it's easier to add a filter later if necessary.
As Tim states in his comment, I also prefer using `Any()` to `Count() > 0` since it doesn't have to actually count the items - it will just check for the existence of one item. Conversely I use `!Any()` instead of `Count() == 0`.
Problem
I am retrieving a list of items using Entity Framework and if there are some items retrieved I do something with them. ``` var items = db.MyTable.Where(t => t.Expiration < DateTime.Now).ToList(); if(items.Count != 0) { // Do something... } ``` The `if` statement could also be written as ``` if(items.Count() != 0) { // Do something... } ``` In the first case, the `.Count` is a `List<T>.Count` property. In the second case, the `.Count()` is `IEnumerable<T>.Count()` extension method. Although both approaches achieve the same result, however, is one more preferred than the other? (Possibly some difference in performance?)