last modified January 4, 2023
In this article, we work with arrays in C#.
Array definition
An array is a collection of data. A scalar variable can hold only oneitem at a time. Arrays, on the other hand, can hold multiple items. These itemsare called elements of the array.
Arrays store data of the same data type. Each element can be referredto by an index. The indexes are zero-based. (The index of the first element iszero.) Arrays are reference types.
We declare arrays to be of a certain data type. The Array
classholds multiple methods for sorting, finding, modifying array elements.
int[] ages;String[] names;float[] weights;
We have three array declarations. The declaration consists of two parts.The type of the array and the array name. The type of an array has a datatype that determines the types of the elements within an array(int
, String
, float
in our case) anda pair of square brackets []
. The brackets indicate that we havean array.
Collections serve a similar purpose to arrays. They are more powerfulthan arrays.
C# initializing arrays
There are several ways, how we can initialize an array in C#.
Program.cs
int[] vals = new int[5];vals[0] = 1;vals[1] = 2;vals[2] = 3;vals[3] = 4;vals[4] = 5;for (int i = 0; i < vals.Length; i++){ Console.WriteLine(vals[i]);}
We declare and initialize a numerical array. The contents of the array areprinted to the console.
int[] vals = new int[5];
Here we declare an array which contains five elements. All elementsare integers.
vals[0] = 1;vals[1] = 2;...
We initialize the array with some data. This is assignment initialization. Theindexes are in the square brackets. Number 1 is going to be the first element ofthe array, 2 the second.
for (int i = 0; i < vals.Length; i++){ Console.WriteLine(vals[i]);}
We go through the array and print its elements. An array has aLength
property, which gives the number of elements in the array.Since arrays are zero based, the indexes are 0..length-1.
We can declare and initialize an array in one statement.
Program.cs
int[] array = new int[] { 2, 4, 5, 6, 7, 3, 2 };foreach (int i in array){ Console.WriteLine(i);}
This is a modified version of the previous program.
int[] array = new int[] {2, 4, 5, 6, 7, 3, 2 };
An array is declared and initialized in one step. The elements are specified inthe curly brackets. We did not specify the length of the array. The compilerwill do it for us.
foreach (int i in array){ Console.WriteLine(i);}
We use the foreach
keyword to traverse the array and print itscontents.
C# Array.Fill
The Array.Fill
method fills the whole array with the given value.
Program.cs
int[] vals = new int[10];Array.Fill<int>(vals, 0);Console.WriteLine(string.Join(", ", vals));
We create an array of integers; the array is filled with zeros.
$ dotnet run0, 0, 0, 0, 0, 0, 0, 0, 0, 0
C# array accessing elements
After an array is created, its elements can be accessed by their index. Theindex is a number placed inside square brackets which follow the array name.
We can use the index from end ^
operator to get elements fromthe end of the array. The ^0
equals to array.Length andthe ^n
to array.Length - n.
Program.cs
string[] names = { "Jane", "Thomas", "Lucy", "David" };Console.WriteLine(names[0]);Console.WriteLine(names[1]);Console.WriteLine(names[2]);Console.WriteLine(names[3]);Console.WriteLine("*************************");Console.WriteLine(names[^1]);Console.WriteLine(names[^2]);Console.WriteLine(names[^3]);Console.WriteLine(names[^4]);
In the example, we create an array of string names. We access each of theelements by its index and print them to the terminal.
string[] names = { "Jane", "Thomas", "Lucy", "David" };
An array of strings is created.
Console.WriteLine(names[0]);Console.WriteLine(names[1]);Console.WriteLine(names[2]);Console.WriteLine(names[3]);
Each of the elements of the array is printed to the console. With thenames[0]
construct, we refer to the first element of the namesarray.
Console.WriteLine(names[^1]);Console.WriteLine(names[^2]);Console.WriteLine(names[^3]);Console.WriteLine(names[^4]);
We access array elements from the end.
$ dotnet runJaneThomasLucyDavid*************************DavidLucyThomasJane
C# implicitly-typed array
C# can infer the type of the array.
Program.cs
var vals = new[] { 1, 2, 3, 4, 5 };var words = new[] { "cup", "falcon", "word", "water" };Console.WriteLine(vals.GetType());Console.WriteLine(words.GetType());
We create two implicitly-typed arrays.
var vals = new[] { 1, 2, 3, 4, 5 };
An array of integers is created. We do not specify the type of the array;the compiler can infer the type from the right side of the assignment.
Console.WriteLine(vals.GetType());Console.WriteLine(words.GetType());
With GetType
, we verify the data types of the arrays.
$ dotnet runSystem.Int32[]System.String[]
C# array modify elements
It is possible to modify the elements of an array - they are not immutable.
Program.cs
int[] vals = { 1, 2, 3, 4 };vals[0] *= 2;vals[1] *= 2;vals[2] *= 2;vals[3] *= 2;Console.WriteLine("[{0}]", string.Join(", ", vals));
We have an array of three integers. Each of the values will be multiplied bytwo.
int[] vals = { 1, 2, 3, 4 };
An array of three integers is created.
vals[0] *= 2;vals[1] *= 2;vals[2] *= 2;vals[3] *= 2;
Using the element access, we multiply each value in the array by two.
Console.WriteLine("[{0}]", string.Join(", ", vals));
With the Join
method, we create one string from all elements ofthe array. The elements are separated with a comma character.
$ dotnet run[2, 4, 6, 8]
All four integers have been multiplied by number 2.
C# array slices
We can use the ..
operator to get array slices. A range specifiesthe start and end of a range. The start of the range is inclusive, but the endof the range is exclusive. It means that the start is included in the range butthe end is not included in the range.
Program.cs
int[] vals = { 1, 2, 3, 4, 5, 6, 7 };int[] vals2 = vals[1..5];Console.WriteLine("[{0}]", string.Join(", ", vals2));int[] vals3 = vals[..6];Console.WriteLine("[{0}]", string.Join(", ", vals3));int[] vals4 = vals[3..];Console.WriteLine("[{0}]", string.Join(", ", vals4));
The example works with array ranges.
int[] vals2 = vals[1..5];
We create an array slice containing elements from index 1 to index 4.
int[] vals3 = vals[..6];
If the start index is omitted, the slice starts from index 0.
int[] vals4 = vals[3..];
If the end index is omitted, the slice goes until the end of the array.
$ dotnet run[2, 3, 4, 5][1, 2, 3, 4, 5, 6][4, 5, 6, 7]
C# traversing arrays
We often need to go through all elements of an array. We show two common methodsfor traversing an array.
Program.cs
string[] planets = { "Mercury", "Venus", "Mars", "Earth", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto" };for (int i=0; i < planets.Length; i++){ Console.WriteLine(planets[i]);}foreach (string planet in planets){ Console.WriteLine(planet);}
An array of planet names is created. We use the for and foreach statements toprint all the values.
for (int i=0; i < planets.Length; i++){ Console.WriteLine(planets[i]);}
In this loop, we utilize the fact that we can get the number of elements fromthe array object. The number of elements is stored in the Length
property.
foreach (string planet in planets){ Console.WriteLine(planet);}
The foreach statement can be used to make the code more compact when traversingarrays or other collections. In each cycle, the planet variable is passed thenext value from the planets array.
C# pass array as function argument
Arrays are passed to functions by reference. This means that the elements ofthe original array can be changed.
Program.cs
var vals = new int[] { 1, 2, 3, 4, 5 };ModifyArray(vals);Console.WriteLine(string.Join(", ", vals));void ModifyArray(int[] data){ Array.Reverse(data);}
We pass an array of integers to the ModifyArray
function. Itreverses the array elements. Since a reference to the array is passed and nota copy, the vals
array is changed.
$ dotnet run 5, 4, 3, 2, 1
C# array dimensions
So far, we have worked with one-dimensional arrays. The number of indexes needed tospecify an element is called the dimension, or rank of the array.
Two-dimensional array
Next, we work with two-dimensional array.
Program.cs
int[,] twodim = new int[,] { {1, 2, 3}, {1, 2, 3} };int d1 = twodim.GetLength(0);int d2 = twodim.GetLength(1);for (int i=0; i<d1; i++){ for (int j=0; j<d2; j++) { Console.WriteLine(twodim[i, j]); }}
If we need two indexes to access an element in an array then we have a twodimensional array.
int[,] twodim = new int[,] { {1, 2, 3}, {1, 2, 3} };
We declare and initialize a two dimensional array in one statement. Note thecomma inside the square brackets.
int d1 = twodim.GetLength(0);int d2 = twodim.GetLength(1);
We get the dimensions of the array. The GetLength
gets the numberof elements in the specified dimension of the array.
for (int i=0; i<d1; i++){ for (int j=0; j<d2; j++) { Console.WriteLine(twodim[i, j]); }}
We use two for
loops to go through all the elements of a twodimensional array. Note that a specific array element is obtained using twoindexes, separated by a comma character.
$ dotnet run123123
We can traverse a two-dimensional array with the foreach loop.
Program.cs
int[,] vals = new int[4, 2]{ { 9, 99 }, { 3, 33 }, { 4, 44 }, { 1, 11 }};foreach (var val in vals){ Console.WriteLine(val);}
With the foreach loop, we get the elements one-by-one from the beginning to theend.
$ dotnet run999333444111
Three-dimensional array
Next, we work with a three dimensional array.
Program.cs
int[,,] n3 ={ {{12, 2, 8}}, {{14, 5, 2}}, {{3, 26, 9}}, {{4, 11, 2}}};int d1 = n3.GetLength(0);int d2 = n3.GetLength(1);int d3 = n3.GetLength(2);for (int i=0; i<d1; i++){ for (int j=0; j<d2; j++) { for (int k=0; k<d3; k++) { Console.Write(n3[i, j, k] + " "); } }}Console.Write('\n');
We have a numerical three-dimensional array. Again, we initialize the array withnumbers and print them to the terminal.
int[,,] n3 = { {{12, 2, 8}}, {{14, 5, 2}}, {{3, 26, 9}}, {{4, 11, 2}}};
There is another comma between the square brackets on the left side andadditional curly brackets on the right side.
for (int k=0; k<d3; k++){ Console.Write(n3[i, j, k] + " ");}
This loop goes through the third dimension. We use three indexes to retrieve thevalue from the array.
$ dotnet run12 2 8 14 5 2 3 26 9 4 11 2
C# Rank
There is a Rank
property which gives the number of dimensions of anarray.
Program.cs
int[] a1 = { 1, 2 };int[,] a2 = { { 1 }, { 2 } };int[,,] a3 = { { { 1, 2 }, { 2, 1 } } };Console.WriteLine(a1.Rank);Console.WriteLine(a2.Rank);Console.WriteLine(a3.Rank);
We have three arrays. We use the Rank
property to get the number ofdimensions for each of them.
Console.WriteLine(a1.Rank);
Here we get the rank for the first array.
$ dotnet run123
C# jagged arrays
Arrays that have elements of the same size are called rectangulararrays. In contrast, arrays which have elements of different size are calledjagged arrays. Jagged arrays are declared and initialized differently.
Program.cs
int[][] jagged = new int[][]{ new int[] { 1, 2 }, new int[] { 1, 2, 3 }, new int[] { 1, 2, 3, 4 }};foreach (int[] array in jagged){ foreach (int e in array) { Console.Write(e + " "); }}Console.Write('\n');
This is an example of a jagged array.
int[][] jagged = new int[][]{ new int[] { 1, 2 }, new int[] { 1, 2, 3 }, new int[] { 1, 2, 3, 4 }};
This is a declaration and initialization of a jagged array. Note that this time,we use two pairs of square brackets. We have an array of arrays. Morespecifically, we have declared an array to have three arrays of int data type.Each of the arrays has different number of elements.
foreach (int[] array in jagged){ foreach (int e in array) { Console.Write(e + " "); }}
We use two foreach loops to traverse the jagged array. In the first loop, we getthe array. In the second loop, we get the elements of the obtained array.
C# array sort & reverse
The Array.sort
method sorts the array elements in-place. TheArray.Reverse
method reverses the sequence of the array elements.
Program.cs
string[] names = {"Jane", "Frank", "Alice", "Tom" };Array.Sort(names);foreach(string el in names){ Console.Write(el + " ");}Console.Write('\n');Array.Reverse(names);foreach(string el in names){ Console.Write(el + " ");}Console.Write('\n');
In this example, we sort and reverse an array of strings.
string[] names = {"Jane", "Frank", "Alice", "Tom" };
We have an array of strings.
Array.Sort(names);
The static Sort
method sorts the data alphabetically.
Array.Reverse(names);
The Reverse
method reverses the sequence of the elements in theentire one-dimensional array.
$ dotnet runAlice Frank Jane TomTom Jane Frank Alice
Alternatively, we can sort arrays with LINQ's Order
andOrderDescending
methods.
Program.cs
string[] names = {"Jane", "Frank", "Alice", "Tom" };var sorted = names.Order();foreach (var name in sorted){ Console.WriteLine(name);}Console.WriteLine("----------------------");var sorted2 = names.OrderDescending();foreach (var name in sorted2){ Console.WriteLine(name);}
The program sorts an array of strings in ascending and descending orders.
$ dotnet runAliceFrankJaneTom----------------------TomJaneFrankAlice
C# array GetValue & SetValue
The SetValue
method sets a value to the element at the specifiedposition. The GetValue
gets the value at the specified position.
Program.cs
string[] names = { "Jane", "Frank", "Alice", "Tom" };names.SetValue("Beky", 1);names.SetValue("Erzebeth", 3);Console.WriteLine(names.GetValue(1));Console.WriteLine(names.GetValue(3));
This example uses the SetValue
and GetValue
methods.
names.SetValue("Beky", 1);names.SetValue("Erzebeth", 3);
The SetValue
sets a value for a specific index in the array.
Console.WriteLine(names.GetValue(1));Console.WriteLine(names.GetValue(3));
We retrieve the values from the array with the GetValue
method.
$ dotnet runBekyErzebeth
C# array Clone & Clear
The Array.Copy
method copies values from the source array to thedestination array. The Array.Clear
deletes all elements of thearray.
Program.cs
string[] names = {"Jane", "Frank", "Alice", "Tom"};string[] names2 = new string[4];Array.Copy(names, names2, names.Length);Console.WriteLine(string.Join(", ", names2));Array.Clear(names2);Console.WriteLine(string.Join(", ", names2));
In the program, we create a copy of an array and later delete it.
Array.Copy(names, names2, names.Length);
The Copy
method copies values from the source array to thedestination array. The first parameter is the source array, the second is thedestination array. The third parameter is the length; it specifies the number ofelements to copy.
Array.Clear(names2);
The Clear
method removes all elements from the array.
$ dotnet runJane, Frank, Alice, Tom, , ,
In this article we have worked with arrays in C#.
List all C# tutorials.