Introduction

In C#, an array is a collection of elements of the same type that are stored in contiguous memory locations and can be accessed using an index. Arrays provide an efficient way of storing and accessing a fixed number of elements.

To declare an array in C#, you specify the data type of the elements in the array, followed by the name of the array, and then the size of the array in square brackets. For example, the following code declares an array of integers with ten elements.

int[] numbers = new int[10];

The syntax to declare an array is the data type of its elements, followed by the array name. On the right side, use the new keyword and the array size.

For example

int[] intArray = new int[5];

The above code snippet creates an array called "intArray" to hold five integers. However, the elements of the Array are not yet initialized, and their values are undefined.

Arrays can also be initialized when they are declared by providing a list of comma-separated values enclosed in curly braces {}

int[] intArray = new int[] {1, 2, 3, 4, 5};

or simply

int[] intArray = {1, 2, 3, 4, 5};

This creates an array called "intArray" with five elements and assigns the values 1, 2, 3, 4, and 5 to the elements of the Array.

The following code snippet declares an array that can store 100 items from index 0 to 99.

int[] intArray;
intArray = new int[100];

Create an array

There are multiple ways to create an array in C#. Here are a few examples.

1. Using the new keyword.

int[] myArray = new int[5];

This creates an array called "myArray" that can hold five integers. Unfortunately, the elements of the Array are not yet initialized, and their values are undefined.

2. Using the new keyword with an array initializer

int[] myArray = new int[] {1, 2, 3, 4, 5};

or simply

int[] myArray = {1, 2, 3, 4, 5};

This creates an array called "myArray" with five elements and assigns the values 1, 2, 3, 4, and 5 to the elements of the Array.

3. Using the var keyword

var myArray = new int[] {1, 2, 3, 4, 5};

This creates an array; the array type is inferred from the initializer, and the Array's name is myArray.

4. Using the stackable keyword

int* myArray = stackalloc int[5];

The stackable keyword allocates memory on the stack rather than the heap. This creates an unmanaged array of integers called "myArray" that can hold five integers. The elements of the Array are not yet initialized, and their values are undefined.

It is worth noting that stack-allocated arrays should be used with care, as they can cause stack overflow if the array size is too large or if they are used in a recursive function.

Initialize Array Initialization

Once an array is created using one of the above methods, the step is initializing an array. The initialization process of an array includes adding actual data to the Array.

The following code snippet creates an array of 3 items, and the values of these items are added when the Array is initialized.

int[] staticIntArray = { 1, 3, 5 };

Or you could initialize the same Array in this way.

// Initialize a fixed array  
int[] staticIntArray = new int[3] {1, 3, 5};   

Alternatively, we can add array items individually, as listed in the following code snippet.

// Initialize a fixed array one item at a time  
int[] staticIntArray = new int[3];  
staticIntArray[0] = 1;  
staticIntArray[1] = 3;  
staticIntArray[2] = 5;   

Note. C# arrays are 0-indexed, meaning that the first element has an index of 0, the second element has an index of 1, and so on.

The following code snippet declares a dynamic array with string values.

// Initialize a dynamic array items during declaration  
string[] strArray = new string[] { "Mahesh Chand", "Mike Gold", "Raj Beniwal", "Praveen Kumar", "Dinesh Beniwal" };  

Access elements in an Array

We can access an array item by passing the item index in the Array. For example, the following code snippet creates an array of three items and displays those items on the console.

// Initialize a fixed array one item at a time  
int[] staticIntArray = new int[3];  
staticIntArray[0] = 1;  
staticIntArray[1] = 3;  
staticIntArray[2] = 5;  
// Read array items one by one  
Console.WriteLine(staticIntArray[0]);  
Console.WriteLine(staticIntArray[1]);  
Console.WriteLine(staticIntArray[2]);   

This method is proper when you know what item to access from an array. You will get an error if you try to pass an item index more significant than the elements in an array.

Loop through an Array

For each control statement (loop) is used to iterate through the elements of an array. For example, the following code uses a for each loop to read all items of an array of strings.

// Initialize a dynamic array items during declaration  
string[] strArray = new string[] {  
    "Mahesh Chand",  
    "Mike Gold",  
    "Raj Beniwal",  
    "Praveen Kumar",  
    "Dinesh Beniwal"  
};  
// Read array items using foreach loop  
foreach(string str in strArray) {  
    Console.WriteLine(str);  
}  

This approach is used when you do not know the exact index of an item in an array and need to loop through all the items.

Types of Arrays

There are four types of arrays in C#.

  1. Single-dimensional arrays
  2. Multi-dimensional arrays or rectangular arrays
  3. Jagged arrays
  4. Mixed arrays.

Single Dimension Array

Single-dimensional arrays are the simplest form of arrays. These arrays are used to store the number of items of a predefined type. All items in a single-dimension array are stored contiguously, starting from 0 to the size of the Array -1.

The following code declares an integer array that can store three items. As you can see from the code, first, I say the Array using [] bracket, and after that, I instantiate the collection by calling the new operator.

int[] intArray;  
intArray = new int[3];  

Array declarations in C# are pretty simple. First, you put array items in curly braces ({}). Then, suppose an array is not initialized. In that case, its items are automatically initialized to the initial default value for the array type if the Array is not initialized when it is declared.

The following code declares and initializes an array of three items of integer type.

int[] staticIntArray = new int[3] {1, 3, 5};  

The following code declares and initializes an array of 5 string items.

string[] strArray = new string[5] { "Mahesh", "Mike", "Raj", "Praveen", "Dinesh" };  

You can even directly assign these values without using the new operator.

string[] strArray = { "Mahesh", "Mike", "Raj", "Praveen", "Dinesh" };  

You can initialize a dynamic length array as follows.

string[] strArray = new string[] { "Mahesh", "Mike", "Raj", "Praveen", "Dinesh" };   

Multi-Dimensional Array

A multi-dimensional array, also known as a rectangular array, has more than one dimension. The form of a multi-dimensional array is a matrix.

Declaring a multi-dimensional array

A multi-dimension array is declared as follows.

string[,] mutliDimStringArray;

A multi-dimensional array can be fixed-sized or dynamic-sized.

Initializing multi-dimensional arrays

The following code snippet is an example of fixed-sized multi-dimensional arrays that define two multi-dimension arrays with a matrix of 3x2 and 2x2. The first Array can store six items, and the second Array can store six items. Both of these arrays are initialized during the declaration.

int[,] numbers = new int[3, 2] { { 1, 2 }, { 3, 4 }, { 5, 6 } };  
string[,] names = new string[2, 2] { { "Rosy", "Amy" }, { "Peter", "Albert" } };  

Now let's see examples of multi-dimensional dynamic arrays where you are unsure of the number of items of the Array. For example, the following code snippet creates two multi-dimensional arrays with no limit.

int[,] numbers = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 } };  
string[,] names = new string[,] { { "Rosy", "Amy" }, { "Peter", "Albert" } };  

You can also omit the new operator as we did in single-dimension arrays. You can assign these values directly without using the new operator. For example.

int[,] numbers = {
    { 1, 2 },
    { 3, 4 },
    { 5, 6 }
};
string[,] names = {
    { "Rosy", "Amy" },
    { "Peter", "Albert" }
};

We can also initialize the array items one item at a time. The following code snippet is an example of initializing array items one at a time.

int[, ] numbers = new int[3, 2];  
numbers[0, 0] = 1;  
numbers[1, 0] = 2;  
numbers[2, 0] = 3;  
numbers[0, 1] = 4;  
numbers[1, 1] = 5;  
numbers[2, 1] = 6;  

Accessing multi-dimensional arrays

Multi-dimensional array items are represented in a matrix format; we need to specify the matrix dimension to access its items. For example, item(1,2) means an array item in the matrix in the second row and third column.

The following code snippet shows how to access the number array defined in the above code.

Console.WriteLine(numbers[0, 0]);  
Console.WriteLine(numbers[0, 1]);  
Console.WriteLine(numbers[1, 0]);  
Console.WriteLine(numbers[1, 1]);  
Console.WriteLine(numbers[2, 0]);  
Console.WriteLine(numbers[2, 2]);

Jagged Arrays

Jagged arrays are arrays of arrays. The elements of a jagged array are other arrays.

Declaring Jagged Arrays

The declaration of a jagged array involves two brackets. For example, the following code snippet declares a jagged array that has three items of an array.

int[][] intJaggedArray = new int[3][];

The following code snippet declares a jagged array with two Array items.

string[][] stringJaggedArray = new string[2][];

Initializing Jagged Arrays

Before a jagged array can be used, its items must be initialized. For example, the following code snippet initializes a jagged array; the first item with an array of integers with two integers, the second item with an array of integers with four integers, and the third item with an array of integers with hassix6 integers.

// Initializing jagged arrays  
intJaggedArray[0] = new int[2];  
intJaggedArray[1] = new int[4];  
intJaggedArray[2] = new int[6];  

We can also initialize a jagged array's items by providing the values of the Array's items. For example, the following code snippet initializes an array's items directly during the declaration.

// Initializing jagged arrays 
intJaggedArray[0] = new int[2] { 
    2, 
    12 
}; 
intJaggedArray[1] = new int[4] { 
    4, 
    14, 
    24, 
    34 
}; 
intJaggedArray[2] = new int[6] { 
    6, 
    16, 
    26, 
    36, 
    46, 
    56 
};

Accessing Jagged Arrays

We can access a jagged array of items individually in the following way:

Console.Write(intJaggedArray3[0][0]);  
Console.WriteLine(intJaggedArray3[2][5]);   

The Length property of an array helps a lot; it gives us the number of items in an array. We can also loop through all of the items of a jagged array. The following code snippet loops through all of the items of a jagged array and displays them on the screen.

// Loop through all itesm of a jagged array  
for (int i = 0; i < intJaggedArray3.Length; i++) {  
    System.Console.Write("Element({0}): ", i);  
    for (int j = 0; j < intJaggedArray3[i].Length; j++) {  
        System.Console.Write("{0}{1}", intJaggedArray3[i][j], j == (intJaggedArray3[i].Length - 1) ? "" : " ");  
    }  
    System.Console.WriteLine();  
}   

Mixed Arrays

Mixed arrays are a combination of multi-dimensional arrays and jagged arrays. The mixed arrays type is removed from .NET 4.0. I have not seen any use of mixed arrays. You can do anything you want with the help of multi-dimensional and jagged arrays.

A Simple Example

Here is a complete example listed in Listing 1 that demonstrates how to declare all kinds of arrays, initialize them, and access them.

To test this code, create a console application using Visual Studio 2010 or Visual C# Express and copy and paste this code.

Console.WriteLine("Single Dimension Array Sample"); 
// Single dim array 
string[] strArray = new string[] { 
    "Mahesh Chand", 
    "Mike Gold", 
    "Raj Beniwal", 
    "Praveen Kumar", 
    "Dinesh Beniwal" 
}; 
// Read array items using foreach loop 
foreach(string str in strArray) { 
    Console.WriteLine(str); 
} 
Console.WriteLine("-----------------------------"); 
Console.WriteLine("Multi-Dimension Array Sample"); 
string[,] string2DArray = new string[2, 2] { 
    { 
        "Rosy", 
        "Amy" 
    }, { 
        "Peter", 
        "Albert" 
    } 
}; 
foreach(string str in string2DArray) { 
    Console.WriteLine(str); 
} 
Console.WriteLine("-----------------------------"); 
Console.WriteLine("Jagged Array Sample"); 
int[][] intJaggedArray3 = { 
    new int[] { 
        2, 
        12 
    }, 
    new int[] { 
        14, 
        14, 
        24, 
        34 
    }, 
    new int[] { 
        6, 
        16, 
        26, 
        36, 
        46, 
        56 
    } 
}; 
// Loop through all items of a jagged array 
for (int i = 0; i < intJaggedArray3.Length; i++) { 
    Console.Write($"Element({i}): "); 
    for (int j = 0; j < intJaggedArray3[i].Length; j++) { 
        Console.Write($"{intJaggedArray3[i][j]} "); 
    } 
    Console.WriteLine(); 
} 
Console.WriteLine("-----------------------------");

Listing 1

The output of Listing One looks like Figure 1.

Output
Figure 1

The Array Class

Array class in C# is the mother of all arrays and provides functionality for creating, manipulating, searching, and sorting arrays in the .NET Framework.

Array class, defined in the System namespace, is the base class for arrays in C#. However, the Array class is an abstract base class, meaning we cannot create an instance of the Array class.

Creating an Array

Array class provides the CreateInstance method to construct an array. The CreateInstance method takes the first parameter as the type of items, and the second and third parameters are the dimension and their range. Once an array is created, we use the SetValue method to add items.

The following code snippet creates an array and adds three items to the Array. As you can see, the type of the array items is a string, and the range is 3. Therefore, you will get an error message if you try adding the 4th item to the Array.

Array stringArray = Array.CreateInstance(typeof(String), 3);  
stringArray.SetValue("Mahesh Chand", 0);  
stringArray.SetValue("Raj Kumar", 1);  
stringArray.SetValue("Neel Beniwal", 2);   

Calling SetValue on an existing item of an array overrides the previous item value with the new value.

The code snippet in Listing 2 creates a multi-dimensional array.

Array intArray3D = Array.CreateInstance(typeof(Int32), 2, 3, 4);  
for (int i = intArray3D.GetLowerBound(0); i <= intArray3D.GetUpperBound(0); i++)  
    for (int j = intArray3D.GetLowerBound(1); j <= intArray3D.GetUpperBound(1); j++)  
        for (int k = intArray3D.GetLowerBound(2); k <= intArray3D.GetUpperBound(2); k++) {  
            intArray3D.SetValue((i * 100) + (j * 10) + k, i, j, k);  
        }  
foreach(int ival in intArray3D) {  
    Console.WriteLine(ival);  
}   

Listing 2

Array Class Properties

Table 1 describes Array class properties.

IsFixedSize Return a value indicating if an array has a fixed size or not.
IsReadOnly Returns a value indicating if an array is read-only or not.
LongLength Returns a 64-bit integer representing the total number of items in an array's dimensions.
Length Returns a 32-bit integer representing the total number of items in an array's dimensions.
Rank Returns the number of dimensions of an array.

The code snippet in Listing 3 creates an array and uses Array properties to display property values.

int[] intArray = new int[3] {    
    0,    
    1,    
    2    
};    
if (intArray.IsFixedSize) {    
    Console.WriteLine("Array is fixed size");    
    Console.WriteLine($"Size : {intArray.Length.ToString()}");  
    Console.WriteLine($"Rank : {intArray.Rank.ToString()}");  
} 

Listing 3

The output of the Listing looks like Figure 2.

C# array properties
Figure 2

Search an element in an Array

The BinarySearch static method of the Array class can be used to search for an item in an array. This method uses the binary search algorithm to search for an item. The method takes at least two parameters. The first parameter is the Array you would like to explore, and the second parameter is an object that is the item you are looking for. If an item is found in the Array, the method returns the index of that item (based on the first item as the 0th item). Otherwise, the process returns a negative value.

Note. You must sort an array before searching. See the comments in this article.

Listing 4 uses the BinarySearch method to search an array for a string.

// Create an array and add 5 items to it    
Array stringArray = Array.CreateInstance(typeof(String), 5);  
stringArray.SetValue("Mahesh", 0);  
stringArray.SetValue("Raj", 1);  
stringArray.SetValue("Neel", 2);  
stringArray.SetValue("Beniwal", 3);  
stringArray.SetValue("Chand", 4);  
// Find an item    
object name = "Neel";  
int nameIndex = Array.BinarySearch(stringArray, name);  
if (nameIndex >= 0) Console.WriteLine($"Item was at {nameIndex.ToString()}th position");  
else Console.WriteLine("Item not found"); 

Listing 4

Sorting an Array

The Sort static method of the Array class can be used to sort array items. This method has many overloaded forms. The simplest form takes as a parameter the Array you want to sort. For example, Listing 5 uses the Sort method to sort array items. You can also sort a partial list of items using the Sort method.

// Create an array and add 5 items to it     
Array stringArray = Array.CreateInstance(typeof(String), 5); 
stringArray.SetValue("Mahesh", 0); 
stringArray.SetValue("Raj", 1); 
stringArray.SetValue("Neel", 2); 
stringArray.SetValue("Beniwal", 3); 
stringArray.SetValue("Chand", 4); 
// Find an item     
object name = "Neel"; 
int nameIndex = Array.BinarySearch(stringArray, name); 
if (nameIndex >= 0) Console.WriteLine($"Item was at {nameIndex.ToString()}th position"); 
else Console.WriteLine("Item not found"); 
Console.WriteLine(); 
Console.WriteLine("Original Array"); 
Console.WriteLine("---------------------"); 
foreach (string str in stringArray) 
{ 
    Console.WriteLine(str); 
} 
Console.WriteLine(); 
Console.WriteLine("Sorted Array"); 
Console.WriteLine("---------------------"); 
Array.Sort(stringArray); 
foreach (string str in stringArray) 
{ 
    Console.WriteLine(str); 
}

Listing 5

The output of Listing 5 looks like Figure 3.

Output of listing
Figure 3

Alternatively, the Sort method takes the starting index and the number of items after that index. For example, the following code snippet sorts three items starting at the 2nd position.

Array.Sort(stringArray, 2, 3);   

The new output looks like Figure 4.

Arrays
Figure 4

Getting and Setting Values

The GetValue and SetValue methods of the Array class can be used to get and set values of an array's items. For example, the code listed in Listing 4 creates a 2-dimensional array instance using the CreateInstance method. After that, I use the SetValue method to add values to the Array.

Ultimately, I find several items in both dimensions and use the GetValue method to read values and display them on the console.

Array names = Array.CreateInstance(typeof(String), 2, 4); 
names.SetValue("Rosy", 0, 0); 
names.SetValue("Amy", 0, 1); 
names.SetValue("Peter", 0, 2); 
names.SetValue("Albert", 0, 3); 
names.SetValue("Mel", 1, 0); 
names.SetValue("Mongee", 1, 1); 
names.SetValue("Luma", 1, 2); 
names.SetValue("Lara", 1, 3); 
int items1 = names.GetLength(0); 
int items2 = names.GetLength(1); 
for (int i = 0; i < items1; i++) 
    for (int j = 0; j < items2; j++) 
        Console.WriteLine($"{i.ToString()},{j.ToString()}: {names.GetValue(i, j)}");

Listing 6

The output of Listing 6 generates Figure 5.

GetValue SetValue
Figure 5

Reverse an Array in C#

The Reverse static method of the Array class reverses the order of items in an array. Similar to the Sort method, you can pass an array as a parameter of the Reverse method.

Array stringArray = Array.CreateInstance(typeof(String), 5);  
stringArray.SetValue("Mahesh", 0);  
stringArray.SetValue("Raj", 1);  
stringArray.SetValue("Neel", 2);  
stringArray.SetValue("Beniwal", 3);  
stringArray.SetValue("Chand", 4);  
Console.WriteLine("Original Array");  
Console.WriteLine("---------------------");  
foreach(string str in stringArray) {  
    Console.WriteLine(str);  
}  
Console.WriteLine();  
Console.WriteLine("Reversed Array");  
Console.WriteLine("---------------------");  
Array.Reverse(stringArray);  
// Array.Sort(stringArray, 2, 3);  
foreach(string str in stringArray) {  
    Console.WriteLine(str);  
}  
Console.WriteLine();  
Console.WriteLine("Double Reversed Array");  
Console.WriteLine("---------------------");  
Array.Reverse(stringArray);  
// Array.Sort(stringArray, 2, 3);  
foreach(string str in stringArray) {  
    Console.WriteLine(str);  
}   

Listing 7

The output of Listing 7 generates Figure 6.

Listing 7
Figure 6

Clear an Array

The Clear static method of the Array class removes all items of an array and sets its length to zero. This method takes three parameters - first, an array object; second, the d starting index of the collection and third, the e number of elements. For example, the following code clears two elements from the Array starting at index 1 (which means the second element of the Array).

Array.Clear(stringArray, 1, 2);   

Note. Keep in mind the Clear method does not delete items. Just clear the values of the items.

The code listed in Listing 8 clears two items from index 1.

Array stringArray = Array.CreateInstance(typeof(String), 5);
stringArray.SetValue("Mahesh", 0);
stringArray.SetValue("Raj", 1);
stringArray.SetValue("Neel", 2);
stringArray.SetValue("Beniwal", 3);
stringArray.SetValue("Chand", 4);

Console.WriteLine("Original Array");
Console.WriteLine("---------------------");
foreach (string str in stringArray)
{
    Console.WriteLine(str);
}

Console.WriteLine();
Console.WriteLine("Clear Items");
Console.WriteLine("---------------------");
Array.Clear(stringArray, 1, 2);
foreach (string str in stringArray)
{
    Console.WriteLine(str);
}

Listing 8

The output of Listing 8 generates Figure 7. As you can see from Figure 7, the values of two items from the output are missing, but the actual items are there.

Listing 8 generates
Figure 7

Get the size of an array

The GetLength method returns the number of items in an array. The GetLowerBound and GetUppperBound methods return an array's lower and upper bounds, respectively. All these three methods take at least a parameter, which is the index of the dimension of an array. For example, the following code snippet uses all three methods.

Console.WriteLine(stringArray.GetLength(0).ToString());  
Console.WriteLine(stringArray.GetLowerBound(0).ToString());  
Console.WriteLine(stringArray.GetUpperBound(0).ToString());  

Copy an Array

The Copy static method of the Array class copies a section of an array to another array. The CopyTo method copies all the elements of a variety to another one-dimension array. For example, the code listed in Listing Nine copies the contents of an integer array to an array of object types.

// Creates and initializes a new Array of type Int32.
Array oddArray = Array.CreateInstance(Type.GetType("System.Int32"), 5);
oddArray.SetValue(1, 0);
oddArray.SetValue(3, 1);
oddArray.SetValue(5, 2);
oddArray.SetValue(7, 3);
oddArray.SetValue(9, 4);

// Creates and initializes a new Array of type Object.
Array objArray = Array.CreateInstance(Type.GetType("System.Object"), 5);
Array.Copy(oddArray, oddArray.GetLowerBound(0), objArray, objArray.GetLowerBound(0), 4);
int items1 = objArray.GetUpperBound(0);
for (int i = 0; i < items1; i++)
    Console.WriteLine(objArray.GetValue(i).ToString());

Listing 9

You can even copy a part of an array to another, bypassing the number of items and starting items in the Copy method. For example, the following format copies various items from an Array starting at the specified source index. Then, it pastes them to another Array starting at the selected destination index.

public static void Copy(Array, int, Array, int, int); 

Clone an Array

The Clone method creates a shallow copy of an array. The references in the new Array point to the same objects as those in the original Array. A shallow copy of an Array copies only the elements of the Array, whether reference types or value types, but it does not copy the objects that the references refer to.

The following code snippet creates a cloned copy of an array of strings.

string[] clonedArray = (string[])stringArray.Clone();   

Convert an Array to a list

You use the ToList method to convert a C# array to a list.

List<string> namesList = names.ToList();

Continue here: Convert an Array to a List in C# (c-sharpcorner.com)

Summary

In this tutorial, you learned how to create different types of arrays in C#, initialize them, and use them in your applications. You also learned the .NET Array class and its properties and methods. Finally, you also learned to use the Array class methods to search, sort, and do other operations on arrays.