C# Arrays

An array is a group of like-typed variables that are referred to by a common name. And each data item is called an element of the array. The data types of the elements may be any valid data type like char, int, float, etc. and the elements are stored in a contiguous location. Length of the array specifies the number of elements present in the array.

The array has can contain primitive data types as well as objects of a class depending on the definition of an array. Whenever use primitives data types, the actual values have to be stored in contiguous memory locations. In the case of objects of a class, the actual objects are stored in the heap segment.

The following figure shows how array stores values sequentially:

Explanation: The index is starting from 0, which stores value. we can also store a fixed number of values in an array. Array index is to be increased by 1 in sequence whenever its not reach the array size.

Array Declaration

Syntax:

<Data Type>[ ] <Name_Array>

Here,

• <Data Type> : It define the element type of the array.
• [ ] : It define the size of the array.
• <Name_Array> : It is the Name of array. 

Note : Only Declaration of an array doesn’t allocate memory to the array. For that array must be initialized.

Array Initialization

As said earlier, an array is a reference type so the new keyword used to create an instance of the array. We can assign initialize individual array elements, with the help of the index. 

Syntax:

type [ ] < Name_Array > = new < datatype > [size];

Here, type specifies the type of data being allocated, size specifies the number of elements in the array, and Name_Array is the name of an array variable. And new will allocate memory to an array according to its size. 

Examples: To Show Different ways for the Array Declaration and Initialization  

Initialization of an Array after Declaration

Arrays can be initialized after the declaration. It is not necessary to declare and initialize at the same time using the new keyword. However, Initializing an Array after the declaration, it must be initialized with the new keyword. It can’t be initialized by only assigning values. 

Example:

// Declaration of the array
string[] str1, str2;

// Initialization of array
str1 = new string[5]{ “Element 1”, “Element 2”, “Element 3”, “Element 4”, “Element 5” };
str2 = new string[5]{ “Element 1”, “Element 2”, “Element 3”, “Element 4”, “Element 5” };

Note : Initialization without giving size is not valid in C#. It will give a compile-time error. 

Example: Wrong Declaration for initializing an array

// Compile-time error: must give size of an array
int[] intArray = new int[];

// Error : wrong initialization of an array
string[] str1;
str1 = {“Element 1”, “Element 2”, “Element 3”, “Element 4” };

Accessing Array Elements

At the time of initialization, we can assign the value. But, we can also assign the value of the array using its index randomly after the declaration and initialization. We can access an array value through indexing, placed index of the element within square brackets with the array name.

Example: Accessing Array elements using different loops

// Accessing array elements using different loops
using System;
	
class Geeks 
{
	// Main Method
	public static void Main()
	{
		// declares an Array of integers.
		int[] intArray;

		// allocating memory for 5 integers.
		intArray = new int[5];

		// initialize the first elements
		// of the array
		intArray[0] = 10;

		// initialize the second elements
		// of the array
		intArray[1] = 20;

		// so on...
		intArray[2] = 30;
		intArray[3] = 40;
		intArray[4] = 50;

		// accessing the elements
		// using for loop
		Console.Write("For loop :");
		for (int i = 0; i < intArray.Length; i++)
			Console.Write(" " + intArray[i]);

		Console.WriteLine("");
		Console.Write("For-each loop :");
		
		// using for-each loop
		foreach(int i in intArray)
			Console.Write(" " + i);

		Console.WriteLine("");
		Console.Write("while loop :");
		
		// using while loop
		int j = 0;
		while (j < intArray.Length) {
			Console.Write(" " + intArray[j]);
			j++;
		}

		Console.WriteLine("");
		Console.Write("Do-while loop :");
		
		// using do-while loop
		int k = 0;
		do
		{
			Console.Write(" " + intArray[k]);
			k++;
		} while (k < intArray.Length);
	}
}

For loop : 10 20 30 40 50
For-each loop : 10 20 30 40 50
while loop : 10 20 30 40 50
Do-while loop : 10 20 30 40 50

Types of Arrays in C#

There are three types of Arrays C# supports as mentioned below:

• One Dimensional Array
• Multi Dimensional Array
• Jagged Array

1. One Dimensional Array

In this array contains only one row for storing the values. All values of this array are stored contiguously starting from 0 to the array size. For example, declaring a single-dimensional array of 5 integers :

int[] arrayint = new int[5];

The above array contains the elements from arrayint[0] to arrayint[4]. Here, the new operator has to create the array and also initialize its element by their default values. Above example, all elements are initialized by zero, Because it is the int type. 

Example:

// Demonstration of One-Dimensional Array
using System;

class Geeks 
{
    // Main Method
    public static void Main()
    {
        // declares a 1D Array of string.
        string[] weekDays;

        // allocating memory for days.
        weekDays = new string[] { "Sun", "Mon", "Tue", "Wed",
                             "Thu", "Fri", "Sat" };

        // Displaying Elements of array
        foreach(string day in weekDays)
            Console.Write(day + " ");
    }
}

Sun Mon Tue Wed Thu Fri Sat 

2. Multidimensional Arrays

The multi-dimensional array contains more than one row to store the values. It is also known as a Rectangular Array in C# because it’s each row length is same. It can be a 2D-array or 3D-array or more. To storing and accessing the values of the array, one required the nested loop. The multi-dimensional array declaration, initialization and accessing is as follows :

// creates a two-dimensional array of
// four rows and two columns.
int[, ] intarray = new int[4, 2];

//creates an array of three dimensions, 4, 2, and 3
int[,, ] intarray1 = new int[4, 2, 3];

Example:

// Demonstration of multi- dimensional array
using System;

class Geeks 
{	
	// Main Method
	public static void Main()
	{									
		// The same array with dimensions 
		// specified 2, 2 and 3.
		int[,, ] arr = new int[2, 2, 3] { { { 1, 2, 3 }, 
											{ 4, 5, 6 } }, 
											{ { 7, 8, 9 }, 
											{ 10, 11, 12 } } };

      	// Checking elements at particular index
		Console.WriteLine("arr[1][0][1] : " 
						+ arr[1, 0, 1]);
							
		Console.WriteLine("arr[1][1][2] : " 
						+ arr[1, 1, 2]);
	}
}

arr[1][0][1] : 8
arr[1][1][2] : 12

3. Jagged Arrays

An array whose elements are arrays is known as Jagged arrays it means “array of arrays“. The jagged array elements may be of different dimensions and sizes. Below are the examples to show how to declare, initialize, and access the jagged arrays. 

Example: Showing how to declare, initialize, and access the jagged arrays

// Demonstration of Jagged Array
using System;
	
class Geeks 
{
	// Main Method
	public static void Main()
	{
        // Declaring Jagged Array
		int[][] arr = { new int[] { 1, 3, 5, 7, 9 },
						new int[] { 2, 4, 6, 8 } };
        
		Console.WriteLine("Arrays :");
      
      	// Display the array elements:
		for (int i = 0; i < arr.Length; i++)
		{
			System.Console.Write("Elements[" + i + "] Array: ");
			
          	// Printing the elements of array
          	for (int j = 0; j < arr[i].Length; j++) {
				Console.Write(arr[i][j] + " ");
            }
          
            Console.WriteLine();
		}
	}
}

Arrays :
Elements[0] Array: 1 3 5 7 9 
Elements[1] Array: 2 4 6 8 

Points To Remember:

• GetLength(int): returns the number of elements in the first dimension of the Array.
• When using jagged arrays be safe as if the index does not exist then it will throw exception which is IndexOutOfRange.

Important Points to Remember About Arrays

• In C#, all arrays are dynamically allocated.
• Since arrays are objects in C#, we can find their length using member length. This is different from C/C++ where we find length using sizeof operator.
• A C# array variable can also be declared like other variables with [] after the data type.
• The variables in the array are ordered and each has an index beginning from 0.
• C# array is an object of base type System.Array.
• Default values of numeric array and reference type elements are set to be respectively zero and null.
• A jagged array elements are reference types and are initialized to null.
• Array elements can be of any type, including an array type.
• Array types are reference types which are derived from the abstract base type Array. These types implement IEnumerable and for it, they use foreach iteration on all arrays in C#.