Is it worthwhile to initialize the collection size of a List if it’s size reasonably known?

by

Yes, it gets to be important when your List<T> gets large. The exact numbers depend on the element type and the machine architecture, let’s pick a List of reference types on a 32-bit machine. Each element will then take 4 bytes inside an internal array. The list will start out with a Capacity of 0 and an empty array. The first Add() call grows the Capacity to 4, reallocating the internal array to 16 bytes. Four Add() calls later, the array is full and needs to be reallocated again. It doubles the size, Capacity grows to 8, array size to 32 bytes. The previous array is garbage.

This repeats as necessary, several copies of the internal array will become garbage.

Something special happens when the array has grown to 65,536 bytes (16,384 elements). The next Add() doubles the size again to 131,072 bytes. That’s a memory allocation that exceeds the threshold for “large objects” (85,000 bytes). The allocation is now no longer made on the generation 0 heap, it is taken from the Large Object Heap.

Objects on the LOH are treated specially. They are only garbage collected during a generation 2 collection. And the heap doesn’t get compacted, it takes too much time to move such large chunks.

This repeats as necessary, several LOH objects will become garbage. They can take up memory for quite a while, generation 2 collections do not happen very often. Another problem is that these large blocks tend to fragment the virtual memory address space.

This doesn’t repeat endlessly, sooner or later the List class needs to re-allocate the array and it has grown so large that there isn’t a hole left in the virtual memory address space to fit the array. Your program will bomb with an OutOfMemoryException. Usually well before all available virtual memory has been consumed.

Long story short, by setting the Capacity early, before you start filling the List, you can reserve that large internal array up front. You won’t get all those awkward released blocks in the Large Object Heap and avoid fragmentation. In effect, you’ll be able to store many more objects in the list and your program runs leaner since there’s so little garbage. Do this only if you have a good idea how large the list will be, using a large Capacity that you’ll never fill is wasteful.

More Related Contents:

  1. How to Sort a List by a property in the object
  2. Convert generic List/Enumerable to DataTable?
  3. How to remove elements from a generic list while iterating over it?
  4. How do I clone a generic list in C#?
  5. ArrayList vs List in C#
  6. Remove duplicates from a List in C#
  7. List or IList [closed]
  8. How to create List of open generic type of class?
  9. Does .NET have a way to check if List a contains all items in List b?
  10. List OrderBy Alphabetical Order
  11. XML Serialize generic list of serializable objects
  12. Combination of List
  13. How to initialize a List to a given size (as opposed to capacity)?
  14. Generic List – moving an item within the list
  15. How do I check if a given value is a generic list?
  16. Console.WriteLine and generic List
  17. Cast Object to Generic List
  18. How to convert c# generic list to json using json.net?
  19. Split a List into smaller lists of N size [duplicate]
  20. Generics in C#, using type of a variable as parameter [duplicate]
  21. Convert a list to a string in C#
  22. Setting generic type at runtime
  23. How can I use interface as a C# generic type constraint?
  24. What is ‘1 in Collection type Name
  25. C# – static types cannot be used as type arguments
  26. Which C# method overload is chosen?
  27. Calling generic static method in PowerShell
  28. Creating a generic method in C#
  29. C# generic methods, type parameters in new() constructor constraint
  30. Eliminate consecutive duplicates of list elements

Leave a Comment