Arrays are a fundamental concept in any programming language, including C#. They allow you to store multiple values in a single variable, making it easier to manage and manipulate data. In this blog, we’ll explore the basics of arrays, how to work with multi-dimensional arrays, and dynamic arrays in C#. We’ll also include some sample code and cover error handling to ensure you have a smooth experience.

What is an Array?

An array is a collection of variables (elements) that are stored in a single, fixed-size data structure. All elements in an array must be of the same data type. For example, you can have an array of integers, an array of strings, or an array of objects.

Additionally, the number of dimensions are set when an array variable is declared. The length of each dimension is established when the array instance is created. These values can’t be changed during the lifetime of the instance.

This will become clear when we discuss the types of arrays in the next section, with examples.

Type of Arrays in C#

An array can be single-dimensional, multidimensional, or jagged. Let’s look at them in more detail with examples.

Single-Dimensional Arrays

A single-dimensional array is a sequence of like elements accessed via its index. The index is its ordinal position in the sequence.

// Declaring an array of integers
int[] numbers = new int[5]; // This array can hold 5 integers

// Assigning values to the array. The first element in the array is at index 0.
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;

// Accessing and printing the values in the array. The for loop iterates through the array and prints each value.
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);      
}

Multi-Dimensional Arrays

Multi-dimensional arrays are arrays of arrays. The most common type is the two-dimensional array, often used to represent a matrix or a table.

Here’s an example of a two-dimensional array:

// Declaring a 2D array (matrix) with 3 rows and 4 columns
int[,] matrix = new int[3, 4];

//We assign values to each element using matrix[row, column] = value;.
matrix[0, 0] = 1;
matrix[0, 1] = 2;
matrix[0, 2] = 3;
matrix[0, 3] = 4;

matrix[1, 0] = 5;
matrix[1, 1] = 6;
matrix[1, 2] = 7;
matrix[1, 3] = 8;

matrix[2, 0] = 9;
matrix[2, 1] = 10;
matrix[2, 2] = 11;
matrix[2, 3] = 12;

// Accessing and printing the values in the 2D array. The nested for loop iterates through each element in the array and prints the matrix row by row.
for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 4; j++)
    {
        Console.Write(matrix[i, j] + " ");
    }
    Console.WriteLine(); // New line after each row
}

Jagged Arrays

A jagged array is essentially an array where each element is itself an array. This means that you can have an array of arrays, and each of these inner arrays can have a different number of elements.

Example: Imagine you have a group of students, and each student is enrolled in a different number of courses. A jagged array is ideal for representing this data, as it allows each student’s list of courses to have a different length.

int[][] jaggedArray = new int[3][]; // Declare a jagged array with 3 rows

// Initialize each row with a different length
jaggedArray[0] = new int[] { 1, 2, 3 };        // Row 0 with 3 elements
jaggedArray[1] = new int[] { 4, 5 };           // Row 1 with 2 elements
jaggedArray[2] = new int[] { 6, 7, 8, 9 };     // Row 2 with 4 elements

Console.WriteLine(jaggedArray[0][1]); // Accesses the second element in the first row (Output: 2)
Console.WriteLine(jaggedArray[2][3]); // Accesses the fourth element in the third row (Output: 9)

//You can use nested loops to iterate over a jagged array. The outer loop iterates through each row, and the inner loop iterates through each element in that row.
for (int i = 0; i < jaggedArray.Length; i++)
{
    Console.WriteLine($"Row {i}:");
    for (int j = 0; j < jaggedArray[i].Length; j++)
    {
        Console.Write(jaggedArray[i][j] + " ");
    }
    Console.WriteLine(); // New line for each row
}

Error Handling with Arrays

When working with arrays, errors can occur if you try to access an element outside the bounds of the array or perform operations that the array doesn’t support. To handle these errors gracefully, we use try-catch blocks.

int[] numbers = new int[3] { 1, 2, 3 };

//The try block contains the code that might throw an exception. The catch block catches the IndexOutOfRangeException and prints an error message instead of crashing the program.

try
{
    // Attempting to access an out-of-bounds index
    Console.WriteLine(numbers[5]);
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("Error: " + ex.Message);
}

When to use arrays?

Arrays are a fundamental data structure in programming, but they aren’t always the best choice for every scenario. Knowing when to use arrays is essential for writing efficient and effective code. Here are some situations where arrays are particularly useful:

1. Fixed Size Data

  • Use Case: When you know the number of elements your data will contain in advance, and this number won’t change.
  • Example: If you’re working with the days of the week, you know there are always 7 days, so an array is ideal.
string[] daysOfWeek = new string[] { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };

2. Homogeneous Data

  • Use Case: When all elements of the data are of the same type, arrays provide a simple way to group these elements together.
  • Example: Storing the scores of a game where all scores are integers 
int[] scores = new int[5] { 10, 15, 20, 25, 30 };

3. Performance Considerations

  • Use Case: Arrays provide fast access to elements (O(1) time complexity for access) because elements are stored in contiguous memory locations. This is beneficial when performance is critical.
  • Example: Storing pixel data for image processing, where each pixel’s color values need to be accessed quickly
byte[] pixels = new byte[width * height * 3]; // RGB values

4. Simple Data Manipulation

  • Use Case: When your data does not require frequent insertions or deletions, arrays are a good fit since these operations can be expensive (O(n) time complexity) in arrays.
  • Example: Keeping track of the top 10 high scores in a game. You may only update the scores occasionally, so an array works well.
int[] highScores = new int[10];

5. Multidimensional Data

  • Use Case: When you need to represent data in a grid or matrix form, such as rows and columns.
  • Example: Storing a 2D game board or a mathematical matrix.
int[,] matrix = new int[3, 3] 
{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

6. Low-Level Data Operations

  • Use Case: Arrays are often used in low-level programming or systems programming, where direct memory access and control are important.
  • Example: Working with raw data buffers or implementing algorithms where memory layout and performance are critical.
char[] buffer = new char[256];

7. Need for Simple Data Structure

  • Use Case: When you need a straightforward data structure without the overhead of more complex collections.
  • Example: Temporarily storing a list of options in a console application where the options won’t change dynamically.
string[] menuOptions = { "Start Game", "Load Game", "Exit" };

8. Low Memory Overhead

  • Use Case: Arrays generally have lower memory overhead compared to other collections like List<T> or Dictionary<K,V>, especially for small datasets.
  • Example: Embedded systems or performance-critical applications where memory usage is a concern.
int[] smallArray = new int[5];

9. Iteration Over Data

  • Use Case: When you need to perform operations on each element of a collection, arrays are easy to loop through using for or foreach loops.
  • Example: Applying a discount to each item in an array of prices.
for (int i = 0; i < prices.Length; i++)
{
    prices[i] *= 0.9; // Apply a 10% discount
}

When Not to Use Arrays:

  • Dynamic Data: If the number of elements in your data can change (i.e., adding/removing items), consider using a List<T> instead.
  • Associative Data: If you need to associate keys with values (like in a dictionary), use a Dictionary<K, V> or Hashtable.
  • Complex Data Structures: If you need more complex behavior like sorting, searching, or custom ordering, other collections like SortedList, Queue, or Stack might be more appropriate.

Conclusion

Working with arrays in C# is a vital skill for any beginner in the coding industry. Whether you are dealing with simple single-dimensional arrays, multi-dimensional arrays, or dynamic arrays, understanding these concepts will give you a strong foundation. Always remember to handle errors properly to make your programs more robust and user-friendly.

Happy coding!

Further Reading:

AI for Absolute Beginners: No Coding Required

Azure Beginners Guide: Do You Need Coding Skills to Learn Azure?