List AddRange performance

Daily Knowledge Drop

When multiple items need to be added to a List, using the AddRange method is generally significantly more performant than using the Add method - however, in some scenarios it might actually be slower!

Benchmarks

In all of the below examples, an initial List of 10, 1000 and 10000 items is used as a source and transferred transferer into another destination List.

One at a time

In this benchmark, the Add method is used to add items to a destination list, one at a time:

public void AllOneAtTime()
{
    var newList = new List<int>();

    foreach(var item in items)
    {
        newList.Add(item);
    }
}

Filtered one at a time

Here, only certain items are added to the destination list (this divisible by 2). A check is performed, and only if it passes is the specific item added to the list:

public void FilteredOneAtTime()
{
    var newList = new List<int>();

    foreach (var item in items)
    {
        // only if divisible by 2
        if (item % 2 == 0)
        {
            newList.Add(item);
        }
    }
}

Add range

In this benchmark, the entire source list is copied to the destination list using the AddRange method:

public void AllOnce()
{
    var newList = new List<int>();

    newList.AddRange(items);
}

Filtered add range

In the final benchmark, the entire source list is filtered using LINQ, and then AddRange is used:

public void FilteredOnce()
{
    var newList = new List<int>();

    newList.AddRange(items.Where(i => i % 2 == 0).ToList());
}

Performance

The full results are below, but in summary:

• AddRange is 2-3 times faster than using Add multiple times (depending on the list size)
• When required to filter the list, its quicker to iterate through each item, perform the check and use Add. This is in comparison to using LINQ to filter and then AddRange (the bottleneck here is LINQ, not the AddRange call)

10 items

1000 items

10000 items

Notes

Generally, AddRange is much quicker than multiple iterations of Add - however, if using AddRange in conjunction with a slower operation (such as LINQ's where), then it doesn't really matter which is used, and to improve performance the bottleneck (LINQ) should be optimized.

References

Sabig Gasim Tweet

Daily Drop 200: 11-11-2022

At the start of 2022 I set myself the goal of learning one new coding related piece of knowledge a day.
It could be anything - some.NET / C# functionality I wasn't aware of, a design practice, a cool new coding technique, or just something I find interesting. It could be something I knew at one point but had forgotten, or something completely new, which I may or may never actually use.

The Daily Drop is a record of these pieces of knowledge - writing about and summarizing them helps re-enforce the information for myself, as well as potentially helps others learn something new as well.