C# - Arrays

An array stores a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type stored at contiguous memory locations.

Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables. A specific element in an array is accessed by an index.

All arrays consist of contiguous memory locations. The lowest address corresponds to the first element and the highest address to the last element.



Declaring Arrays

To declare an array in C#, you can use the following syntax:



where,

• datatype is used to specify the type of elements in the array.
  
• [ ] specifies the rank of the array. The rank specifies the size of the array.
  
• arrayName specifies the name of the array.
  

For example,



Initializing an Array

Declaring an array does not initialize the array in the memory. When the array variable is initialized, you can assign values to the array.

Array is a reference type, so you need to use the new keyword to create an instance of the array. For example,



Assigning Values to an Array

You can assign values to individual array elements, by using the index number, like:



You can assign values to the array at the time of declaration, as shown:



You can also create and initialize an array, as shown:



You may also omit the size of the array, as shown:



You can copy an array variable into another target array variable. In such case, both the target and source point to the same memory location:



When you create an array, C# compiler implicitly initializes each array element to a default value depending on the array type. For example, for an int array all elements are initialized to 0.

Accessing Array Elements

An element is accessed by indexing the array name. This is done by placing the index of the element within square brackets after the name of the array. For example,



The following example, demonstrates the above-mentioned concepts declaration, assignment, and accessing arrays:



When the above code is compiled and executed, it produces the following result:



Using the foreach Loop

In the previous example, we used a for loop for accessing each array element. You can also use a foreach statement to iterate through an array.



When the above code is compiled and executed, it produces the following result:



C# Arrays

There are following few important concepts related to array which should be clear to a C# programmer:



Multidimensional Arrays

C# allows multidimensional arrays. Multi-dimensional arrays are also called rectangular array. You can declare a 2-dimensional array of strings as:



or, a 3-dimensional array of int variables as:



Two-Dimensional Arrays

The simplest form of the multidimensional array is the 2-dimensional array. A 2-dimensional array is a list of one-dimensional arrays.

A 2-dimensional array can be thought of as a table, which has x number of rows and y number of columns. Following is a 2-dimensional array, which contains 3 rows and 4 columns:



Thus, every element in the array a is identified by an element name of the form a[ i , j ], where a is the name of the array, and i and j are the subscripts that uniquely identify each element in array a.

Initializing Two-Dimensional Arrays

Multidimensional arrays may be initialized by specifying bracketed values for each row. The Following array is with 3 rows and each row has 4 columns.



Accessing Two-Dimensional Array Elements

An element in 2-dimensional array is accessed by using the subscripts. That is, row index and column index of the array. For example,



The above statement takes 4th element from the 3rd row of the array. You can verify it in the above diagram. Let us check the program to handle a two dimensional array:



When the above code is compiled and executed, it produces the following result:



Jagged Arrays

A Jagged array is an array of arrays. You can declare a jagged array named scores of type int as:



Declaring an array, does not create the array in memory. To create the above array:



You can initialize a jagged array as:



Where, scores is an array of two arrays of integers - scores[0] is an array of 3 integers and scores[1] is an array of 4 integers.

Example

The following example illustrates using a jagged array:



When the above code is compiled and executed, it produces the following result:



Passing Arrays as Function Arguments

You can pass an array as a function argument in C#. The following example demonstrates this:



When the above code is compiled and executed, it produces the following result:



Param Arrays

At times, while declaring a method, you are not sure of the number of arguments passed as a parameter. C# param arrays (or parameter arrays) come into help at such times.

The following example demonstrates this:



When the above code is compiled and executed, it produces the following result:



Array Class

The Array class is the base class for all the arrays in C#. It is defined in the System namespace. The Array class provides various properties and methods to work with arrays.

Properties of the Array Class

The following table describes some of the most commonly used properties of the Array class:



Methods of the Array Class

The following table describes some of the most commonly used methods of the Array class:



For complete list of Array class properties and methods, please consult Microsoft documentation on C#.

Example

The following program demonstrates use of some of the methods of the Array class:



When the above code is compiled and executed, it produces the following result: