R – Strange LINQ behavior – ToList returning empty set

entity-frameworklinq

I cant understand why resultSet2 is empty! Only the first assert passes!

List<Tree> resultSet1 = this.datacontext.Trees.Where(t=>t.RiskRating.Contains("bad")).ToList();

Assert.IsTrue(resultSet1.count() == 3);


List<Tree> resultSet2 = this.datacontext.Trees.ToList().Where(t=>t.RiskRating.Contains("bad")).ToList();

Assert.IsTrue(resultSet2.count() == 3);

Thanks!

Ashley

Best Solution

What does this.datacontext.Trees.ToList().Count() return?

Could it be something to do with your collation back at the database? The first example will convert the Contains("bad") method back to SQL, which might be case insensitive and return rows that contain "BAD" or "Bad". The second example wouldn't be case sensitive.

It'd be interesting to see what the values for RiskRating are back in the database, and what the SQL query getting executed looks like.

Related Solutions

C# – Checking if a list is empty with LINQ

You could do this:

public static Boolean IsEmpty<T>(this IEnumerable<T> source)
{
    if (source == null)
        return true; // or throw an exception
    return !source.Any();
}

Edit: Note that simply using the .Count method will be fast if the underlying source actually has a fast Count property. A valid optimization above would be to detect a few base types and simply use the .Count property of those, instead of the .Any() approach, but then fall back to .Any() if no guarantee can be made.

.net – Is it better to call ToList() or ToArray() in LINQ queries

Unless you simply need an array to meet other constraints you should use ToList. In the majority of scenarios ToArray will allocate more memory than ToList.

Both use arrays for storage, but ToList has a more flexible constraint. It needs the array to be at least as large as the number of elements in the collection. If the array is larger, that is not a problem. However ToArray needs the array to be sized exactly to the number of elements.

To meet this constraint ToArray often does one more allocation than ToList. Once it has an array that is big enough it allocates an array which is exactly the correct size and copies the elements back into that array. The only time it can avoid this is when the grow algorithm for the array just happens to coincide with the number of elements needing to be stored (definitely in the minority).

EDIT

A couple of people have asked me about the consequence of having the extra unused memory in the List<T> value.

This is a valid concern. If the created collection is long lived, is never modified after being created and has a high chance of landing in the Gen2 heap then you may be better off taking the extra allocation of ToArray up front.

In general though I find this to be the rarer case. It's much more common to see a lot of ToArray calls which are immediately passed to other short lived uses of memory in which case ToList is demonstrably better.

The key here is to profile, profile and then profile some more.

Best Solution

Related Solutions

C# – Checking if a list is empty with LINQ

.net – Is it better to call ToList() or ToArray() in LINQ queries

Related Question