Relocation<\/h1>\n\n\n\n
Let’s consider following code:<\/p>\n\n\n\n
public List<int> AddOnebyOne(List<int> list)\n{\n foreach (var item in list)\n _list.Add(item);\n\n return _list;\n}\n\npublic List<int> AddRange(List<int> list)\n{\n _list.AddRange(list);\n\n return _list;\n}<\/code><\/pre>\n\n\n\nWe have two methods: AddOneByOne and AddRange. Their implementation is straightforward: AddOneByOne concatenate two lists by adding elements one by one and AddRange adds whole list. The outcome in both cases is the same. The main difference is what happens behind the scenes.<\/p>\n\n\n\n
The List<\/a> class stores elements in its internal structure. The internal structure has its capacity that can be accessed by the Capacity<\/a> property. If you define the List object’s capacity (using this constructor<\/a>) then the internal array will have the size of the passed capacity. Everything works great until you want to add an element when your list’s internal array is full. Such a scenario causes relocation. The list has to allocate new array with greater capacity and then move all elements there.<\/p>\n\n\n\nAdd vs AddRange<\/h1>\n\n\n\n
The AddRange<\/a> has one important advantage over the Add <\/a> method when it comes to lists concatenation. If you go to the Remarks<\/a> section you can read: “If the new\u00a0Count<\/a>\u00a0(the current\u00a0Count<\/a>\u00a0plus the size of the collection) will be greater than\u00a0Capacity<\/a>, the capacity of the\u00a0List<T><\/a>\u00a0is increased by automatically reallocating the internal array to accommodate the new elements, and the existing elements are copied to the new array before the new elements are added.”. Thanks to that you can avoid many relocations and have only one. <\/p>\n\n\n\nNow, think of the list concatenation in terms of aforementioned relocation. The Add method adds elements one by one until it surpasses the internal array’s size. Once the array is full the relocation happen. If the concatenated list is long such a relocation will occur many times, therefore decreasing the overall performance of concatenation.<\/p>\n\n\n\n
Performance<\/h1>\n\n\n\n
Now, let’s take a look at the benchmark results. The “listSize” is the size of the base list that the elements are added to. The “listToAddSize” is the size of the list whose elements are added to the base list.<\/p>\n\n\n\n![\"\"](\"https:\/\/baldsolutions.com\/wp-content\/uploads\/2022\/02\/image-6.png\")
<\/figure>\n\n\n\nThe results show that using AddRange<\/a>, when it comes to lists concatenation, can speed up the concatenation ~2 times.<\/p>\n\n\n\nSummary<\/h1>\n\n\n\n
To sum up, AddRange<\/a> method might speed up your program execution time when the program consists of some kind of lists concatenation operations. One of the good practice is to define the initial list capacity that is big enough to store all elements throughout the program execution. However, DO NOT create list with to big capacity “just in case” because it is just memory waste. Dynamic relocation is not a bad thing as it adjusts your data structure the to particular scenario, so you should not be afraid of instantiating the list object without the initial capacity. As always it all depends on your particular case which approach is the one you should use.<\/p>\n\n\n\nAs always I’ve prepared an example and you can find it on my github<\/a>, project: Add-vs-AddRange<\/a>, test project: Add-vs-AddRange-tests<\/a>, benchmark project: Add-vs-AddRange-benchmark<\/a>. I encourage you to go through the code, debug it and try to test your own scenarios.<\/p>\n\n\n\nHave a nice day, bye!<\/p>\n","protected":false},"excerpt":{"rendered":"
Introduction Adding elements to a list seems like a pretty common operation. The most intuitive solutions is to invoke some kind of “Add” method on…<\/p>\n