C# Array with Examples

by

Arrays in C# are used to store fixed-size sequential collections of elements of the same type. They are particularly useful when developers need to aggregate data and perform operations on multiple elements simultaneously.

Understanding arrays in C# is essential for any developer for various tasks such as data storage, sorting, and searching algorithms. Arrays are declared by specifying the type of data they will hold, followed by square brackets. This is followed by the instantiation of the array, where the size is defined. C# arrays are zero-indexed, meaning the position of the first element is at index 0.

C# provides several methods and properties to work with arrays efficiently. For instance, the Length property returns the total number of elements in the C# array, and iteration can be achieved using loops. To illustrate how arrays function in C#, examples with different types of data, such as integers, strings, and objects, will showcase creation, initialization, and various operations, such as adding or removing elements, as well as multi-dimensional arrays.

Understanding C# Arrays

C# arrays are a fundamental data structure used to store collections of elements of the same type. They offer a convenient means of grouping variables and are accessible by numerical indices.

Array Basics

Arrays in C# are a collection of variables that hold elements of a single data type. They are fixed in size once defined and can be single-dimensional, multidimensional, or jagged. Indexes in arrays start at 0 meaning the first element of an array is accessed at index 0.

Array Declaration

The declaration of an array sets up the structure of the array and specifies its type and the number of dimensions. To declare an array in C#, one uses the type of the array followed by square brackets. For example, int[] declares an array of integers.

Array Initialization

Once an array is declared, it must be initialized. Initialization can be done explicitly by specifying the size of the array within the square brackets. An array can also be initialized with values, which simultaneously sets its size.

For instance, int[] array = new int[5]; initializes an empty array of five integers, whereas int[] array = {1, 2, 3, 4, 5}; initializes an array with five integers already in it.

Working with C# Arrays

C# arrays are data structures that store fixed-size sequential collections of elements of the same type. They are a key component in C# used for storing and manipulating collections of data.

Accessing Array Elements

An array element can be accessed by its index, with the indexing starting at 0. Here’s how one can access the third element of an array named sampleArray:

int thirdElement = sampleArray[2];

Iterating Through Arrays

One can loop through each element of the array using a for loop or a foreach loop. Below is an example with a for loop iterating over myArray:

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

Multidimensional Arrays

Multidimensional arrays can be either rectangular or jagged. A rectangular 2D array’s declaration and element access would look like this:

int[,] rectArray = new int[3,2];
int element = rectArray[0,1];

For a jagged array (an array of arrays), you might see:

int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4];
int jaggedElement = jaggedArray[0][1];

Array Class Methods

The Array class provides various methods for creating, manipulating, and sorting arrays. For example, to reverse an array named arr:

Array.Reverse(arr);

To find an element within an array, one might use IndexOf:

int index = Array.IndexOf(arr, value);

Advanced C# Array Concepts

Advanced array concepts in C# provide developers with powerful tools to create complex data structures, perform efficient sorting and searching operations, and manipulate array data effectively.

Jagged Arrays

Jagged arrays are arrays of arrays, where each “child” array can have a different length. In C#, they are declared using multiple square brackets.

For example: int[][] jaggedArray = new int[3][]; Here, one can initialize the child arrays individually like jaggedArray[0] = new int[5];

Array Sorting

Sorting arrays in C# can be achieved using various methods, but the most common is the use of the Array.Sort() method. This method works in-place and alters the original array. For multi-dimensional arrays, developers must sort each sub-array independently.

Array Searching

To search for elements, C# provides methods such as Array.IndexOf() and Array.Find(). The former returns the first index of the found item, whereas Array.Find() returns the first matching element based on a predicate.

Manipulating Arrays

Arrays can be manipulated through methods like Array.Copy(), which allows for copying elements from one array to another. The Array.Resize<T>() method is used to change the size of an array, albeit by creating a new array and copying the elements from the old array to the new one.

C# Array Examples

In this section, examples demonstrate how to work with arrays in C#. These examples provide code snippets for creating, manipulating, and accessing arrays in various configurations.

Creating and Using Single-Dimensional Arrays

To create a single-dimensional array in C#, one declares the type of elements with square brackets and initializes it with a specific size or initializer list.

Example:

int[] numbers = new int[5]; // Declare an array of 5 integers
numbers[0] = 1; // Assign value to the first element
numbers[1] = 2; // Assign value to the second element
// ... Initialize other elements

Alternatively, use an array initializer:

int[] numbers = { 1, 2, 3, 4, 5 }; // Declare and initialize the array

Working with Multidimensional Arrays

Multidimensional arrays can be thought of as arrays of arrays. Define them with multiple sets of square brackets.

Example of a two-dimensional array:

int[,] matrix = new int[2, 3]; // Declare a 2x3 matrix
matrix[0, 0] = 1; // Assign values to the matrix
matrix[0, 1] = 2;
// ... Continue assigning values

Implementing Jagged Arrays

Jagged arrays are arrays whose elements are arrays, potentially of different sizes. Declare a jagged array by placing successive square brackets.

Example:

int[][] jaggedArray = new int[3][]; // Declare a jagged array
jaggedArray[0] = new int[4]; // First row has 4 columns
jaggedArray[1] = new int[5]; // Second row has 5 columns
// ... Initialize other rows

Common Array Operations

Several common operations can be performed on arrays, such as sorting, searching, and iterating over elements.

  • Sorting an array:
int[] array = { 9, 3, 8, 5, 1 };
Array.Sort(array); // Sorts the array in ascending order
  • Searching for an element:
int index = Array.IndexOf(array, 8); // Returns the index of the element 8
  • Iterating over an array:
foreach (int item in array) {
    Console.WriteLine(item); // Prints each element in the array
}

Conclusion

Arrays in C# serve as fundamental structures for storing fixed-size sequential collections of elements. In this C# tutorial, what is an array in C#? How to work with arrays in C# with a few examples.

Key Points:

  • Arrays hold elements of the same type.
  • Their size must be specified at the time of declaration.
  • They provide fast access to elements via indexing.

You may also like: