Question

I always thought that the default constructor for List would initialize a list with a capacity of 4 and that the capacity would be doubled when adding the 5th element, etc…

In my application I make a lot of lists (tree like structure where each node can have many children), some of these nodes won’t have any children and since my application was fast but was also using a bit much memory I decided to use the constructor where I can specify the capacity and have set this at 1.

The strange thing now is that the memory usage when I start with a capacity of 1 is about 15% higher then when I use the default constructor. It can’t be because of a better fit with 4 since the doubling would be 1,2,4. So why this extra increase in memory usage? As an extra test I’ve tried to start with a capacity of 4. This time again the memory usage was 15% higher then when using no specified capacity.

Now this really isn’t a problem, but it bothers me that a pretty simple data structure that I’ve used for years has some extra logic that I didn’t know about yet. Does anyone have an idea of the inner workings of List in this aspect?

Answer 1

That’s because if you use the default constructor the internal storage array is set to an empty array, but if you use the constructor with a set size an array of the correct size gets set immediately, instead of being generated on the first call to Add.

You can see this using a decompiler like JustDecompile:

public List(int capacity)
{
    if (capacity < 0)
    {
        ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
    }
    this._items = new T[capacity];
}

public List()
{
    this._items = List<T>._emptyArray;
}

If you look at the Add function it calls EnsureCapacity, which will enlarge the internal storage array if required. Obviously, if the array is set to an empty array initially the first add will create the default size array.