C# Modify Array Values: Direct Assignment and Alternatives

C# modify array values is a routine task for developers working with collections of data. The simplest method is direct assignment through the indexer, but there are other approaches that better suit specific scenarios such as bulk updates, high-performance code, or dynamic resizing.

Direct Assignment with the Indexer

The most straightforward way to change an element is to assign a new value to a specific index. Arrays in C# are zero-based, so the first element is at index 0.

int[] numbers = { 1, 2, 3, 4, 5 };
numbers[2] = 30; // numbers becomes { 1, 2, 30, 4, 5 }

This works for both value types and reference types. For reference types, the assignment replaces the reference stored in the array slot, not the object itself. If you need to modify a property of an object inside an array, you must first retrieve the object and then change its property.

class Point { public int X; public int Y; }

Point[] points = { new Point { X = 1, Y = 2 } };
points[0].X = 10; // modifies the object's property

The indexer assignment is O(1) and does not allocate any additional memory. It is the fastest way to modify a single element.

Modifying Multiple Elements with Array.Copy

When you need to copy a range of values from one array to another, Array.Copy is a built-in method that handles bulk assignment efficiently. It can copy elements between two arrays, or even within the same array as long as the source and destination ranges do not overlap incorrectly.

int[] source = { 10, 20, 30, 40, 50 };
int[] destination = new int[source.Length];
Array.Copy(source, 1, destination, 0, 3); // copies 20, 30, 40

This is useful when you are reshaping data or need to shift elements. However, Array.Copy does not allow you to set all elements to a specific value; for that you would use a loop or Array.Fill.

Using Span<T> for Efficient In-Place Modification

Span<T> provides a type-safe and memory-safe view over a contiguous region of memory, including arrays. It is particularly useful when you want to modify a slice of an array without creating a new array or copying data.

int[] data = { 1, 2, 3, 4, 5, 6 };
Span<int> slice = data.AsSpan(1, 4); // elements 2,3,4,5
slice[0] = 20; // modifies data[1] directly

Because Span<T> is a ref struct, it cannot be used in async methods or as a field in a class. But for synchronous, performance-critical code, it avoids the overhead of array bounds checking in some scenarios and enables zero-copy manipulation of subarrays.

Converting Arrays to Lists for Flexible Modification

If you need to insert or remove elements, an array is not the right structure because its size is fixed. In such cases, converting the array to a List<T> gives you the ability to add, remove, and insert elements while retaining the ability to convert back to an array when needed.

int[] original = { 1, 2, 3 };
List<int> list = original.ToList();
list.Add(4);
list.RemoveAt(0);
int[] modified = list.ToArray(); // { 2, 3, 4 }

This approach allocates a new list and then a new array, so it is less efficient than in-place modification. Use it only when the collection size must change dynamically.

Performance Considerations for Array Mutation

Direct index assignment is the fastest way to modify a single element because it performs no allocation and has constant time complexity. Array.Copy is optimized at the runtime level and is faster than a manual loop for copying large ranges. Span<T> offers the best performance for slicing operations because it avoids creating intermediate arrays. Converting to List<T> involves allocation and copying, so it should be reserved for scenarios where dynamic resizing is required.

When modifying arrays in a hot path, measure the actual impact. The difference between direct assignment and Span<T> is often negligible for small arrays, but for large arrays, avoiding unnecessary copies can be significant.

Common Pitfalls When Modifying Arrays

One common mistake is accessing an index outside the array's bounds, which throws an IndexOutOfRangeException. Always validate the index when it comes from user input or a computed value.

Another issue arises when you store value types in an array and expect modifications to persist. For example, modifying a struct's field through an array indexer works because the indexer returns a reference to the actual storage location. However, if you copy the element to a local variable, changes to that variable do not affect the array.

struct Point { public int X; }
Point[] pts = { new Point { X = 1 } };
Point p = pts[0];
p.X = 5; // pts[0].X remains 1

For reference types, the array stores references, so modifying the object's properties through the reference works as expected. But assigning a new object to an index changes the reference, not the original object.

Understanding these behaviors helps you avoid subtle bugs when working with arrays in C#.