Here Arrays are divided into the following
sections:
- General
Arrays
- Declaring
Arrays
- Initializing
Arrays
- Accessing
Array Members
- Arrays
are Objects
- Using
for each with Arrays
Arrays in General
In C# we can call arrays as zero indexed because the array indexes
start at zero. Arrays in C# work similarly to how arrays work in most other
popular languages there are, however, a few differences that you should be
aware of.
When declaring an array, the square brackets ([]) must come after
the type, not the identifier. Placing the brackets after the identifier is not
legal syntax in C#.
int[] sajil; // not int sajil[];
Another think is that the
size of the array is not part of its type as it is in the C language. This
allows you to declare an array and assign any array of int objects to it, regardless of the array's
length.
int[] num; // declare num as an int array of any size
num = new int[10]; // num is a 10-element array
num = new int[20]; // now it's a 20-element array
Declaring Arrays
In C# we can Create single-dimensional arrays, multidimensional
arrays (rectangular arrays), and array-of-arrays (jagged arrays). The following
examples show how to declare different kinds of arrays:
Single-dimensional arrays:
int[] num;
Multidimensional arrays:
String [,] nam;
Array-of-arrays (jagged):
Byte [][] score;
Declaring them (as shown above) does not actually create the arrays.
In C#, arrays are objects and must be instantiated. The following examples show
how to create arrays:
Single-dimensional arrays:
int [] num = new int [5];
Multidimensional arrays:
String [,] name = new string [5, 4];
Array-of-arrays (jagged):
byte[][] score = new byte[5][];
for (int x = 0; x < score.Length; x++)
{
score[x] = new byte[4];
}
You can also have larger arrays. For example, you can have a
three-dimensional rectangular array:
int[,,] buttons = new int[4,5,3];
You can even mix rectangular and jagged arrays. For example, the
following code declares a single-dimensional array of three-dimensional arrays
of two-dimensional arrays of type int:
int[][,,][,] numbers;
Example
The following is a complete C# program that declares and
instantiates arrays as discussed above.
// array.cs
using System;
class Sample
{
public static void Main()
{
// Single-dimensional array
int[] num = new int[5];
// Multidimensional array
string[,] name = new string[5,4];
// Array-of-arrays (jagged array)
byte[][] score = new byte[5][];
// Create the jagged array
for (int i = 0; i < score.Length; i++)
{
score[i] = new byte[i+3];
}
// Print length of each row
for (int i = 0; i < score.Length; i++)
{
Console.WriteLine("Length of row {0} is {1}", i, score[i].Length);
}
}
}
Output
Length of row 0 is 3
Length of row 1 is 4
Length of row 2 is 5
Length of row 3 is 6
Length of row 4 is 7
Initializing Arrays
C# provides simple ways to initialize arrays at declaration time
by enclosing the initial values in curly braces ({}). The following examples
show different ways to initialize different kinds of arrays.
Note If you do not initialize an array at the time of declaration, the
array members are automatically initialized to the default initial value for
the array type. Also, if you declare the array as a field of a type, it will be
set to the default value null when you instantiate the type.
Single-Dimensional Array
int[] num = new int[5] {1, 2, 3, 4, 5};
string[] name = new string[3] {"sajil", "vinoth", "viji"};
You can omit the size of the array, like this:
int[] num = new int[] {1, 2, 3, 4, 5};
string[] name = new string[] {" sajil ", " vinoth ", " viji "};
You can also omit the new operator if an initializer is provided,
like this:
int[] numbers = {1, 2, 3, 4, 5};
string[] names = {" sajil ", " vinoth ", " viji "};
Multidimensional Array
int[,] numbers = new int[3, 2] { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = new string[2, 2] { {" sajil ","viji"}, {"anand","vinoth"} };
You can omit the size of the array, like this:
int[,] numbers = new int[,] { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = new string[,] { {" sajil ","viji"}, {"anand","vinoth"} };
You can also omit the new operator if an initializer is provided,
like this:
int[,] numbers = { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = { {"sajil", "viji"}, {"anand", "vinoth"} };
Jagged Array
(Array-of-Arrays)
You can initialize jagged arrays like this example:
int[][] num = new int[2][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };
You can also omit the size of the first array, like this:
int[][] num = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };
-or-
int[][] numb = { new int[] {2,3,4}, new int[] {5,6,7,8,9} };
Notice that there is no initialization syntax for the elements of
a jagged array.
Accessing Array Members
Accessing array members is straightforward and similar to how you
access array members in C/C++. For example, the following code creates an array
called numbers and
then assigns a 5 to the fifth element of the array:
int[] num = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
numbers[4] = 5;
The following code declares a multidimensional array and assigns 5 to the
member located at [1, 1]:
int[,] num = { {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10} };
numb[1, 1] = 5;
The following is a declaration of a single-dimension jagged array
that contains two elements. The first element is an array of two integers, and
the second is an array of three integers:
int[][] num = new int[][] { new int[] {1, 2}, new int[] {3, 4, 5}
};
The following statements assign 58 to the first element of the
first array and 667 to the second element of the second array:
num[0][0] = 58;
num[1][1] = 667;
Arrays are Objects
In C#, arrays are actually objects. System.Array is the abstract base type of all array
types. You can use the properties, and other class members, that System.Array has. An example of this would be using the
Length property
to get the length of an array. The following code assigns the length of the numbers array,
which is 5, to a variable calledLengthOfNumbers:
int[] num = {1, 2, 3, 4, 5};
int LengthOfNumbers = num.Length;
The System.Array class provides many other useful
methods/properties, such as methods for sorting, searching, and copying arrays.
Using foreach on Arrays
C# also provides the foreach statement. This statement provides a
simple, clean way to iterate through the elements of an array. For example, the
following code creates an array called numbers and iterates through it with the foreach statement:
int[] num = {4, 5, 6, 1, 2, 3, -2, -1, 0};
foreach (int i in num)
{
System.Console.WriteLine(i);
}
With multidimensional arrays, you can use the same method to
iterate through the elements, for example:
int[,] num = new int[3, 2] {{9, 99}, {3, 33}, {5, 55}};
foreach(int i in num)
{
Console.Write("{0} ", i);
}
The output of this example is:
9 99 3 33 5 55
However, with multidimensional arrays, using a nested for loop gives you more control over the array
elements.
