Is it better to call ToList() or ToArray() in LINQ queries?

Question

I often run into the case where I want to eval a query right where I declare it. This is usually because I need to iterate over it multiple times and it is expensive to compute. For example:

string raw = "...";
var lines = (from l in raw.Split('\n')
             let ll = l.Trim()
             where !string.IsNullOrEmpty(ll)
             select ll).ToList();

This works fine. But if I am not going to modify the result, then I might as well call ToArray() instead of ToList().

I wonder however whether ToArray() is implemented by first calling ToList() and is therefore less memory efficient than just calling ToList().

Am I crazy? Should I just call ToArray() - safe and secure in the knowledge that the memory won't be allocated twice?

Answer 1

The performance difference will be insignificant, since List<T> is implemented as a dynamically sized array. Calling either ToArray() (which uses an internal Buffer<T> class to grow the array) or ToList() (which calls the List<T>(IEnumerable<T>) constructor) will end up being a matter of putting them into an array and growing the array until it fits them all.

If you desire concrete confirmation of this fact, check out the implementation of the methods in question in Reflector -- you'll see they boil down to almost identical code.

Answer 2

I agree with mquander that the performance difference is not going to be significant. I'd go for ToList() in most cases, for extra comfort.

Not strictly part of your question, but for other readers: if you're just looping through the result once, then you don't have to do either ToList() or ToArray(). The IQueryable will calculate the result on demand, which will then be enumerated in your foreach.

Answer 3

If you ever want to find out what happens behind the curtains in .NET, i really recommend .NET Reflector

Answer 4

The memory will always be allocated twice - or something close to that. As you can not resize an array, both methods will use some sort of mechanism to gather the data in a growing collection. (Well, the List is a growing collection in itself.)

The List uses an array as internal storage, and doubles the capacity when needed. This means that by average 2/3 of the items has been reallocated at least once, half of those reallocated at least twice, half of those at least thrice, and so on. That means that each item has by average been reallocated 1.3 times, which is not very much overhead.

Remember also that if you are colleting strings, the collection itself only contains the references to the strings, the strings themselves aren't reallocated.

Answer 5

ToList() is usually preferred if you use it on IEnumerable (from ORM, for instance). If the length of sequence is not known at the beginning, ToArray() creates dynamic-length collection like List and then converts it to array, which takes extra time.