Comprehensive Guide to Adding Values to C# Arrays: Methods and Performance Analysis

Fundamental Concepts and Characteristics of Arrays

In the C# programming language, arrays represent a fundamental data structure designed to store collections of elements of the same type. Unlike dynamic languages such as PHP and JavaScript, C# arrays feature fixed-length characteristics, meaning their size cannot be altered once created. This design choice stems from C#'s strict memory management requirements as a compiled language.

Arrays store elements in contiguous memory blocks, enabling highly efficient element access through indexing. Each element maintains a fixed offset in memory, allowing the CPU to directly calculate and access data at specific positions. However, this contiguous storage characteristic also introduces limitations—when elements need to be added or removed, new arrays must be created and existing data copied.

Direct Index Assignment Method

For arrays with known sizes, the most straightforward approach involves using index-based assignment. This method delivers optimal performance by directly manipulating specific memory locations.

int[] terms = new int[400];
for (int runs = 0; runs < 400; runs++)
{
    terms[runs] = runs;
}

In this example, we first create an array containing 400 integers, then assign values to each index position through iteration. The key advantage of this approach lies in its execution efficiency, particularly when handling large arrays. It's crucial to ensure index values remain within the array's valid range (0 to array length minus 1), otherwise an IndexOutOfRangeException will be thrown.

Flexible Solutions Using List Collections

When array sizes are uncertain or frequent modifications are required, using the List<T> class presents a superior alternative. Lists internally implement arrays but provide dynamic resizing capabilities.

List<int> termsList = new List<int>();
for (int runs = 0; runs < 400; runs++)
{
    termsList.Add(runs);
}

// Optional: Convert List back to array
int[] terms = termsList.ToArray();

The List's Add method automatically handles memory allocation and capacity expansion. When current capacity becomes insufficient, List creates a new, larger internal array and copies existing elements to it. While this mechanism introduces minor overhead, it provides significant flexibility.

Performance Comparison Analysis

Based on actual testing data, significant performance differences exist among various methods:

• Direct index assignment represents the fastest method with O(n) time complexity
• List's Add method performs slightly slower but offers dynamic expansion convenience
• LINQ operations (such as Concat and Append) generate additional overhead
• Array.SetValue method demonstrates the poorest performance and should be avoided in performance-sensitive scenarios

In tests involving 1000 elements, direct index assignment required only 304.2 nanoseconds, while the SetValue method needed 6308.1 nanoseconds—approximately a 20-fold difference. This disparity becomes more pronounced as array sizes increase.

Advanced Extension Techniques

Beyond basic methods, C# offers multiple advanced techniques for handling array extensions:

Array Operations Using LINQ

char[] letters = ['a', 'b'];
letters = letters.Append('c').ToArray();
letters = letters.Concat(['d', 'e']).ToArray();

LINQ methods provide declarative programming styles but require awareness that they create new array instances. This approach suits small arrays requiring infrequent modifications.

Array Copying Techniques

int[] sourceArray = new int[] { 100, 101, 102 };
int[] targetArray = new int[3];
sourceArray.CopyTo(targetArray, 0);

Array.CopyTo and Array.Copy methods enable efficient data copying between arrays, particularly suitable for batch operation scenarios.

Memory Management Considerations

When selecting array operation methods, memory allocation impacts must be considered:

• Direct index assignment and List.ToArray produce deterministic memory allocations
• LINQ operations may generate temporary objects, increasing garbage collection pressure
• Frequent reconstruction of large arrays leads to memory fragmentation

For applications with extreme performance requirements, pre-allocating sufficiently large arrays or employing object pooling techniques for array instance reuse is recommended.

Practical Application Recommendations

Based on different application scenarios, the following selection strategies are recommended:

• Known Fixed Size: Use direct index assignment
• Dynamic Size Requirements: Use List<T>, converting to arrays when necessary
• Small Datasets: LINQ can be used for improved code readability
• High-Performance Requirements: Avoid SetValue and frequent array reconstruction

By understanding the characteristics and performance profiles of these methods, developers can make more informed technical choices, writing C# code that is both efficient and maintainable.