C# - CRUD Operations on Arrays

CRUD Operations using Arrays in C#

Arrays are fundamental data structures in C#, offering efficient indexed storage of fixed-size, homogeneous data. CRUD stands for Create, Read, Update, and Delete – the four essential operations for managing any form of data. Although arrays in C# are fixed in size once created, understanding how to effectively perform CRUD operations with arrays is crucial to writing efficient and maintainable C# code.

Understanding Arrays in C#

Arrays are reference types in C# and are derived from the base System.Array class. They provide fast indexed access to elements and can hold primitive types (like int, double) or complex user-defined types (like class or struct).

Syntax Overview

// Declaration
int[] numbers = new int[5];

// Initialization
numbers[0] = 1;
numbers[1] = 2;

// Inline Initialization
int[] primes = new int[] {2, 3, 5, 7, 11};

Now, let’s dive into each aspect of CRUD operations on arrays in C#.

1. Create Operation

Creating Arrays

The Create operation refers to initializing and allocating memory for an array. Since arrays are reference types, using the new keyword allocates memory on the heap.

string[] fruits = new string[3];

This line declares and allocates space for 3 string elements, each initialized to null.

Initialization at the Time of Declaration

int[] ages = { 21, 25, 30, 35 };

Creating Multi-Dimensional Arrays

int[,] matrix = new int[2, 3] {
    {1, 2, 3},
    {4, 5, 6}
};

Creating Jagged Arrays

int[][] jagged = new int[3][];
jagged[0] = new int[] {1, 2};
jagged[1] = new int[] {3, 4, 5};
jagged[2] = new int[] {6};

2. Read Operation

Accessing Elements

Reading array values is done through indexed access:

Console.WriteLine(fruits[0]);

Remember, array indices start from 0. Accessing an index outside the bounds throws an IndexOutOfRangeException.

Looping Through Arrays

Using For Loop

for (int i = 0; i < fruits.Length; i++) {
    Console.WriteLine(fruits[i]);
}

Using Foreach Loop

foreach (string fruit in fruits) {
    Console.WriteLine(fruit);
}

Using LINQ

var filtered = fruits.Where(f => f.StartsWith("A"));

Array Properties Useful for Reading

• Length: Total number of elements
• Rank: Number of dimensions
• GetLength(dimension): Number of elements in the specified dimension

3. Update Operation

Updating Individual Elements

fruits[1] = "Banana";

Updates the second element in the array.

Updating with Loops

Suppose we want to double every number in an integer array:

for (int i = 0; i < numbers.Length; i++) {
    numbers[i] *= 2;
}

Update Based on Condition

for (int i = 0; i < fruits.Length; i++) {
    if (fruits[i] == "Apple")
        fruits[i] = "Green Apple";
}

Using LINQ Select (returns new array)

int[] doubled = numbers.Select(n => n * 2).ToArray();

Note: LINQ’s Select doesn't update the original array; it creates a new one.

4. Delete Operation

Deleting items in a fixed-size array doesn't reduce the array's length. Instead, we simulate deletion by setting the value to a default, or by creating a new array.

Setting Element to Default

fruits[1] = null;

Creating New Array Without the Element

int[] original = {1, 2, 3, 4, 5};
int deleteIndex = 2;
int[] newArray = new int[original.Length - 1];

for (int i = 0, j = 0; i < original.Length; i++) {
    if (i == deleteIndex) continue;
    newArray[j++] = original[i];
}

Using LINQ to Exclude Element

int[] filtered = original.Where((val, idx) => idx != deleteIndex).ToArray();

Resizing Arrays

C# arrays are fixed in length. If you want to "resize" an array, you can use Array.Resize method, which creates a new array internally.

int[] arr = { 1, 2, 3 };
Array.Resize(ref arr, 5);

The new array now has 5 elements. The last two are initialized to default values (0).

Implementing CRUD with Methods

Create Array

int[] CreateArray(int size) {
    return new int[size];
}

Read Array

void PrintArray(int[] arr) {
    foreach (int val in arr) {
        Console.Write(val + " ");
    }
    Console.WriteLine();
}

Update Element

void UpdateElement(int[] arr, int index, int newValue) {
    if (index >= 0 && index < arr.Length)
        arr[index] = newValue;
}

Delete Element (Create New Array)

int[] DeleteElement(int[] arr, int index) {
    if (index < 0 || index >= arr.Length) return arr;

    int[] result = new int[arr.Length - 1];
    for (int i = 0, j = 0; i < arr.Length; i++) {
        if (i == index) continue;
        result[j++] = arr[i];
    }
    return result;
}

Real-World Example: CRUD on Student List

class Student {
    public string Name { get; set; }
    public int Age { get; set; }
}

Student[] students = new Student[3];
students[0] = new Student { Name = "Alice", Age = 20 };
students[1] = new Student { Name = "Bob", Age = 22 };
students[2] = new Student { Name = "Charlie", Age = 21 };

// Read
foreach (var student in students) {
    Console.WriteLine(student.Name + " - " + student.Age);
}

// Update
students[1].Age = 23;

// Delete (simulate by creating new array)
int deleteIndex = 0;
Student[] updated = new Student[students.Length - 1];
for (int i = 0, j = 0; i < students.Length; i++) {
    if (i != deleteIndex) updated[j++] = students[i];
}

Limitations of Arrays for CRUD

• Fixed size makes deletion and insertion complex
• Frequent resizing creates performance overhead
• Better alternatives like List<T> exist for dynamic data

Best Practices

• Use arrays for static, homogeneous, and performance-critical data
• Validate indices during update/delete operations
• Use Array.Copy and LINQ for immutability patterns
• Consider Span<T> for slicing without copying (C# 7.2+)

Performing CRUD operations on arrays in C# requires an understanding of how arrays work internally. While the operations are conceptually simple, limitations arise due to the fixed size of arrays. Through proper use of loops, conditions, the System.Array class, and LINQ, developers can efficiently manipulate arrays even without resizing capabilities.

For dynamic data needs, collections like List<T> offer more flexibility and easier management. However, mastering CRUD on arrays builds a strong foundation for understanding how memory and data structures work in lower-level programming contexts, which is invaluable for building performant software in C#.