C# - CRUD Operations on Arrays

CRUD Operations on Arrays in C#

Introduction to CRUD Operations on Arrays in C#

CRUD Operations in C# Arrays is one of the most important concepts for beginners and intermediate developers learning C# programming. CRUD stands for Create, Read, Update, and Delete. These four operations form the foundation of data manipulation in almost every application, including web development, desktop applications, APIs, and enterprise systems.

In this detailed guide, we will deeply explore C# CRUD Operations on Arrays, covering theory, practical implementation, performance considerations, interview-focused explanations, and best practices. This content is specially structured for learners who want strong fundamentals in C# arrays, array data manipulation, and data structures in C#.

Understanding Arrays in C#

Before learning CRUD Operations on Arrays in C#, we must clearly understand what an array is.

An array in C# is a fixed-size collection of elements of the same data type stored in contiguous memory locations. Arrays are part of the core C# Data Structures and are widely used in real-world applications.

Key Characteristics of C# Arrays

• Fixed size once declared
• Stores elements of the same type
• Indexed starting from 0
• Fast access using index

Declaring and Initializing an Array

using System;

class Program
{
    static void Main()
    {
        int[] numbers = new int[5];
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;

        foreach (int num in numbers)
        {
            Console.WriteLine(num);
        }
    }
}

Now that we understand arrays, let's move to the main concept: C# CRUD Operations on Arrays.

Create Operation in C# Arrays

The Create operation refers to inserting or adding elements into an array. Since arrays in C# are fixed in size, creation typically happens at initialization. However, we can simulate dynamic behavior using resizing techniques.

1. Creating an Array During Declaration

int[] students = { 101, 102, 103, 104 };

2. Creating and Assigning Values Later

int[] marks = new int[3];
marks[0] = 85;
marks[1] = 90;
marks[2] = 78;

3. Adding a New Element (Simulated Create)

Since arrays are fixed, to add a new element, we create a new larger array and copy values.

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 10, 20, 30 };

        int[] newArray = new int[numbers.Length + 1];

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

        newArray[numbers.Length] = 40;

        foreach (int num in newArray)
        {
            Console.WriteLine(num);
        }
    }
}

This demonstrates Create in CRUD Operations on Arrays in C#.

Read Operation in C# Arrays

The Read operation retrieves data from an array using index-based access or iteration methods.

1. Accessing by Index

int[] numbers = { 10, 20, 30 };
Console.WriteLine(numbers[1]);

2. Using For Loop

int[] numbers = { 5, 10, 15, 20 };

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

3. Using Foreach Loop

int[] numbers = { 5, 10, 15, 20 };

foreach (int num in numbers)
{
    Console.WriteLine(num);
}

Reading is the fastest operation in C# Array Manipulation because it directly accesses memory using an index.

Update Operation in C# Arrays

The Update operation modifies existing data at a specific index in the array.

Updating a Value by Index

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 70, 80, 90 };

        scores[1] = 85;

        foreach (int score in scores)
        {
            Console.WriteLine(score);
        }
    }
}

Here, the value at index 1 was updated from 80 to 85.

Updating Based on Condition

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 10, 20, 30, 20 };

        for (int i = 0; i < numbers.Length; i++)
        {
            if (numbers[i] == 20)
            {
                numbers[i] = 25;
            }
        }

        foreach (int num in numbers)
        {
            Console.WriteLine(num);
        }
    }
}

This approach is useful in real-world Create Read Update Delete in C# scenarios.

Delete Operation in C# Arrays

Deleting elements from an array is slightly tricky because arrays are fixed-size. We simulate delete by shifting elements and optionally resizing.

Deleting an Element by Index

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 10, 20, 30, 40 };
        int indexToDelete = 1;

        for (int i = indexToDelete; i < numbers.Length - 1; i++)
        {
            numbers[i] = numbers[i + 1];
        }

        Array.Resize(ref numbers, numbers.Length - 1);

        foreach (int num in numbers)
        {
            Console.WriteLine(num);
        }
    }
}

Deleting by Value

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 5, 10, 15, 20 };
        int valueToDelete = 15;
        int index = -1;

        for (int i = 0; i < numbers.Length; i++)
        {
            if (numbers[i] == valueToDelete)
            {
                index = i;
                break;
            }
        }

        if (index != -1)
        {
            for (int i = index; i < numbers.Length - 1; i++)
            {
                numbers[i] = numbers[i + 1];
            }

            Array.Resize(ref numbers, numbers.Length - 1);
        }

        foreach (int num in numbers)
        {
            Console.WriteLine(num);
        }
    }
}

This completes the Delete operation in C# CRUD Operations on Arrays.

Real-World CRUD Example in C# Arrays

Let us build a simple Student Management system using CRUD Operations on Arrays in C#.

using System;

class Program
{
    static void Main()
    {
        string[] students = new string[3];
        students[0] = "Asha";
        students[1] = "Ravi";
        students[2] = "Kiran";

        Console.WriteLine("Reading Students:");
        foreach (string s in students)
        {
            Console.WriteLine(s);
        }

        students[1] = "Arjun";

        Console.WriteLine("After Update:");
        foreach (string s in students)
        {
            Console.WriteLine(s);
        }

        Array.Resize(ref students, students.Length - 1);

        Console.WriteLine("After Delete:");
        foreach (string s in students)
        {
            Console.WriteLine(s);
        }
    }
}

Time Complexity of CRUD Operations on Arrays in C#

Create

O(n) when resizing is required

Read

O(1) for index access

Update

O(1) for direct index

Delete

O(n) due to shifting elements

Arrays vs List in CRUD Operations

While learning CRUD Operations on Arrays in C#, it is important to understand that arrays are fixed size. If your application requires frequent insertions and deletions, using List<T> is more efficient.

Understanding C# CRUD Operations on Arrays is essential for mastering C# programming fundamentals. Arrays form the base of data manipulation and help developers understand memory management, indexing, and algorithmic efficiency.

By mastering Create, Read, Update, Delete in C#, you build a strong foundation for advanced topics like collections, LINQ, file handling, databases, and enterprise application development.