C# Tip: Improve memory allocation by initializing collection size

Sometimes just a minor change can affect performance. Here’s a simple trick: initialize your collections by specifying the initial size!

Table of Contents

Just a second!
If you are here, it means that you are a software developer. So, you know that storage, networking, and domain management have a cost .

If you want to support this blog, please ensure that you have disabled the adblocker for this site. I configured Google AdSense to show as few ADS as possible - I don't want to bother you with lots of ads, but I still need to add some to pay for the resources for my site.

Thank you for your understanding.
- Davide

When you initialize a collection, like a List, you create it with the default size.

Whenever you add an item to a collection, .NET checks that there is enough capacity to hold the new item. If not, it resizes the collection by doubling the inner capacity.

Resizing the collection takes time and memory.

Therefore, when possible, you should initialize the collection with the expected number of items it will contain.

Initialize a List

In the case of a List, you can simply replace new List<T>() with new List<T>(size). By specifying the initial size in the constructor’s parameters, you’ll have a good performance improvement.

Let’s create a benchmark using BenchmarkDotNet and .NET 8.0.100-rc.1.23455.8 (at the time of writing, .NET 8 is still in preview. However, we can get an idea of the average performance).

The benchmark is pretty simple:

[MemoryDiagnoser]
public class CollectionWithSizeInitializationBenchmarks
{
    [Params(100, 1000, 10000, 100000)]
    public int Size;

    [Benchmark]
    public void WithoutInitialization()
    {
        List<int> list = new List<int>();

        for (int i = 0; i < Size; i++)
        {

            list.Add(i);
        }
    }

    [Benchmark(Baseline = true)]
    public void WithInitialization()
    {
        List<int> list = new List<int>(Size);

        for (int i = 0; i < Size; i++)
        {
            list.Add(i);
        }
    }
}

The only difference is in the list initialization: in the WithInitialization, we have List<int> list = new List<int>(Size);.

Have a look at the benchmark result, split by time and memory execution.

Starting with the execution time, we can see that without list initialization, we have an average 1.7x performance degradation.

If we talk about memory allocation, we waste an overage of 2.5x memory if compared to collections with size initialized.

Initialize an HashSet

Similar to what we’ve done with List’s, we can see significant improvements when initializing correctly other data types, such as HashSet’s.

Let’s run the same benchmarks, but this time, let’s initialize a HashSet<int> instead of a List<int>.

The code is pretty similar:

 [Benchmark]
 public void WithoutInitialization()
 {
     var set = new HashSet<int>();

     for (int i = 0; i < Size; i++)
     {
         set.Add(i);
     }
 }

 [Benchmark(Baseline = true)]
 public void WithInitialization()
 {
     var set = new HashSet<int>(Size);

     for (int i = 0; i < Size; i++)
     {
         set.Add(i);
     }
 }

What can we say about performance improvements?

If we talk about execution time, we can see an average of 2x improvements.

If we look at memory allocation, if we don’t initialize the HashSet, we are slowing down the application by a factor of 3x. Impressive!

Wrapping up

Do you need other good reasons to initialize your collection capacity when possible? 😉

I used BenchmarkDotNet to create these benchmarks. If you want an introduction to this tool, you can have a look at how I used it to measure the performance of Enums:

🔗 Enum.HasFlag performance with BenchmarkDotNet | Code4IT

I hope you enjoyed this article! Let’s keep in touch on Twitter or LinkedIn! 🤜🤛

Happy coding!

🐧