C # arrays

Array overview

The C # array is indexed from zero, that is, the array index is zero-based. Arrays in C # work similar to how they work in most other popular languages. But there are some differences that should be brought to the attention.

When declaring an array, square brackets ([]) must follow the type, not after the identifier. In C #, placing square brackets after an identifier is not a valid syntax.

Int[] table; not int table[];

Another detail is that the size of the array is not part of its type, whereas in C it is part of the array type. This allows you to declare an array and assign it an arbitrary array of int objects, regardless of the length of the array.

Int[] numbers; Declare numbers as an int array of any size

Numbers = new INT[10]; Numbers is a 10-element array

Numbers = new INT[20]; Now it ' s a 20-element array

declaring an array

C # supports arrays of one-dimensional arrays, multidimensional arrays (rectangular arrays) and arrays (jagged arrays). The following example shows how to declare arrays of different types:

One-dimensional arrays:

Int[] numbers;

Multidimensional Arrays:

string[,] names;

Array of arrays (interleaved):

Byte[][] scores;

declaring arrays (as shown above) does not actually create them. In C #, arrays are objects (discussed later in this tutorial) and must be instantiated. The following example shows how to create an array:

One-dimensional arrays:

int[] numbers = new INT[5];

Multidimensional Arrays:

string[,] names = new string[5,4];

Array of arrays (interleaved):

Byte[][] scores = new byte[5][];

{

SCORES[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 a rectangular array with a jagged array. For example, the following code declares a one-dimensional array of three-dimensional arrays of two-dimensional arrays of type int .

int[][,,][,] numbers;

initializing an array

C # provides a simple and straightforward way to initialize an array at declaration time by enclosing the initial value in curly braces ({}). The following example shows various methods for initializing arrays of different types.

Note If the array is not initialized at the time of declaration, the array member is automatically initialized to the default initial value of the array type. Also, if an array is declared as a field of a type, it is set to the default value NULL when the type is instantiated .

One-dimensional arrays

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

string[] names = new String[3] {"Matt", "Joanne", "Robert"};

You can omit the size of the array, as follows:

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

string[] names = new string[] {"Matt", "Joanne", "Robert"};

If you provide an initializer, you can also omit the new operator, as follows:

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

String[] names = {"Matt", "Joanne", "Robert"};

Multidimensional Arrays

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

string[,] siblings = new string[2, 2] {"Mike", "Amy"}, {"Mary", "Albert"};

You can omit the size of the array, as follows:

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

string[,] siblings = new string[,] {{"Mike", "Amy"}, {"Mary", "Albert"};

If you provide an initializer, you can also omit the new operator, as follows:

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

string[,] siblings = {"Mike", "Amy"}, {"Mary", "Albert"};

jagged Array (array of arrays)

You can initialize a jagged array as shown in the following example:

int[][] numbers = new int[2][] {new int[] {2,3,4}, new int[] {5,6,7,8,9}};

The size of the first array can be omitted, as follows:

int[][] numbers = new int[][] {new int[] {2,3,4}, new int[] {5,6,7,8,9}};

Or

int[][] numbers = {new int[] {2,3,4}, new int[] {5,6,7,8,9}};

Note that there is no initialization syntax for elements of a jagged array.

Accessing Array members

Access to an array member can be done directly, similar to accessing an array member in C + +. For example, the following code creates an numbers array named, and then assigns a 5 to the fifth element of the array :

int[] numbers = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};

NUMBERS[4] = 5;

The following code declares a multidimensional array and [1, 1] assigns to the member that is located 5 :

int[,] numbers = {{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}};

Numbers[1, 1] = 5;

The following declares a one-dimensional jagged array that contains two elements. The first element is an array of two integers, and the second element is an array of three integers:

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

};

The following statement assigns 58 to the first element of the first array and 667 to the second element of the second array:

Numbers[0][0] = 58;

NUMBERS[1][1] = 667;

An array is an object

In C #, an array is actually an object. System.Array is the abstract base type for all array types. You can use the properties that System.Array has and other class members. An example of this usage is to get the length of the array using the Length property. The following code assigns the length of the numbers array (for 5 ) to LengthOfNumbers a variable named:

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

int lengthofnumbers = numbers. Length;

System.Array The class provides a number of useful other methods /properties, such as methods for sorting, searching, and copying arrays.

using foreach with arrays

C # also provides a foreach statement. This statement provides a simple, straightforward way to iterate through the elements of an array. For example, the following code creates an numbers array named and iterates through the array with a foreach statement:

int[] Numbers = {4, 5, 6, 1, 2, 3,-2,-1, 0};

foreach (int i in numbers)

{

System.Console.WriteLine (i);

}

Because of the multidimensional array, you can iterate through the elements using the same method, for example:

int[,] numbers = new int[3, 2] {{9, 99}, {3, 33}, {5, 55}};

foreach (int i in numbers)

{

Console.Write ("{0}", i);

}

The output of this example is:

9 99 3 33 5 55

However, because of the multidimensional array, using a nested for Loop will give you more control over the array elements.

C # array