.NET Collections and the Large Object Heap (LOH)

Question

Are .NET collections with large number of items apt to be stored in the LOH?

I'm curious about List and Dictionary specifically. In my code, I store a large number (40k+) of relatively small objects (lets say 1k) in temporary Lists and Dictionarys for processing. Does the number of items in these collections increase the likelihood of being put on the LOH?

For list, assuming that List is implemented as a doubly linked list, then the number of elements should not increase the size of the actual List object, but I'd like to know for sure.

Thanks

Answer 1

System.Collections.Generic.List is implemented as an array internally, not a linked list. And yes, if the size of the collection is large it'll be allocated on large object heap (note that the size of the array is important, if you have a small array of large reference types, it won't be allocated on LOH).

Answer 2

List is implemented as an array. As such the array will be put into LOH, but the List object itself will not.

The same basically applies to Dictionary as well. It too is using an array of buckets internally, which basically store the key/value pairs you add.

Answer 3

Objects will only be stored on the LOH if they are over 85,000 bytes. A large list (especially of structs) will often get allocated here.

However, Dictionary's are less likely, since they're storing an array of buckets, so unless the generate enough buckets so the array becomes >85000 bytes, it's unlikely. A list of 40k elements will be stored on the LOH, even if they're classes (since the object references in each element will cause the list to be 160k on x86, 320k on x64 systems). The individual elements will be on the standard heap, though, so will get compacted, etc.

If you are using a doubly linked list instead of a standard List, it is very unlikely that it will get stored on the LOH. Each element of the list will be small (just a single node with references to the next/previous nodes), so no single object will be >85k bytes.

For details on the LOH, this is a great blog entry.

Answer 4

Dictionary has O(LOG N) vector for the key/value, so in 40K+ objects your pretty safe. As said here before List is implemented as array so big list are indeed on the LOH. You can check if you object is on the LOH using SOS.