C# Arrays

 An array is a list of items or collection of elements which is of same or similar data type.
 An array is a collection of elements of a single data type stored in adjacent memory
locations.
 An array is a collection of related values placed in contiguous memory locations and these
values are referenced using a common array name.
 An array simplifies the task of maintaining these values
 An array always stores values of a single data type.
 Each value is referred to as an element.
 These elements are accessed using subscripts or index numbers that determine the
position of the element in the array list.
 C# supports zero-based index values in an array.
 This means that the first array element has an index number zero while the last element
has an index number n-1, where n stands for the total number of elements in the array.
 This arrangement of storing values helps in efficient storage of data, easy sorting of data,
and easy tracking of the data length.

Declaring Arrays
 Declaration
 An array declaration specifies the type of data that it can hold and an identifier.
 This identifier is basically an array name and is used with a subscript / index to retrieve or
set the data value at that location.
 Memory allocation:
 Declaring an array does not allocate memory to the array.
 Following is the syntax for declaring an array:

data_type[] arrayName;

 data_type: Specifies the data type of the array elements (for example, int and char).
 arrayName: Specifies the name of the array.

Initializing Arrays

An array can be:

 Created using the new keyword and then initialized.
 Initialized at the time of declaration itself, in which case the new keyword is not used.
 Creating and initializing an array with the new keyword involves specifying the size of an
array.
 The number of elements stored in an array depends upon the specified size.
 The new keyword allocates memory to the array and values can then be assigned to the
array.
 If the elements are not explicitly assigned, default values are stored in the array.

The following table lists the default values for some of the widely
used data types:

DATA TYPES DEFAULT VALUES

int 0

float 0.0

double 0.0

char '\0'

string Null

The following syntax is used to create an array:

type[] arrayName = new type[size-value];

 Size-value: Specifies the number of elements in the array. You can specify a variable of
type int that stores the size of the array instead of directly specifying a value.

The following code creates an integer array which can have a

maximum of five elements in it:

int[] number = new int[5];

 number[0] = 11;
number[1] = 22;
number[2] = 33;
number[3] = 44;
number[4] = 55;

The following syntax is used to create and initialize an array without

using the new keyword:

type[] arrayIdentifier = {val1, val2, val3, ..., valN};

 val1: It is the value of the first element.

 valN: It is the value of the nth element.

Example:

public string[] studNames = new string{“ANKIT”, “RAM”, “ROHIT”, “AMAN”};

Using The Foreach Loop For Arrays

The foreach loop:

 In C# is an extension of the for loop.

 Is used to perform specific actions on large data collections and can even be used on
arrays.
 Reads every element in the specified array.
 Allows you to execute a block of code for each element in the array.
 Is particularly useful for reference types, such as strings.
 Eg:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ArraysDemo
{
class Program
{
static void Main(string[] args)
{
 string[] myArray = { "ANKIT", "SAINI", "AMAN", "RAM" };
Console.WriteLine(myArray.Length);
for (int i = 0; i < myArray.Length; i++)
{
Console.WriteLine(myArray[i]);
}
foreach (string name in myArray)
{
Console.WriteLine(name);
}
Console.WriteLine("Foreach Loop Ends..");
int[] myArray = new int[] { 10,20,30,40 };
int[] myArray = new int[4];
myArray[0] = 10;
myArray[1] = 20;
myArray[2] = 30;
myArray[3] = 40;
Console.WriteLine(myArray[0]);
Console.WriteLine(myArray[1]);
Console.WriteLine(myArray[2]);
Console.WriteLine(myArray[3]);
Console.ReadLine();
}
}
}

Example: Find Minimum and Maximum Element

using System;
// provides us various methods to use in an array
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ArrayMinMax {
class Program {
static void Main(string[] args) {
int[] numbers = {51, 1, 3, 4, 98};
// get the minimum element
Console.WriteLine("Smallest Element: " + numbers.Min());
// Max() returns the largest number in array
Console.WriteLine("Largest Element: " + numbers.Max());
Console.ReadLine();
}
}
}
Note: It is compulsory to use the System.Linq namespace while using Min() , Max() , Sum() , Count() ,
and Average() methods.
C# Multidimensional Array
In a multidimensional array, each element of the array is also an array. For example,

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

X is a multidimensional array which has two elements: {1, 2, 3} and {3, 4, 5}. And,
each element of the array is also an array with 3 elements.

Two-dimensional array in C#
A two-dimensional array consists of single-dimensional arrays as its elements. It can
be represented as a table with a specific number of rows and columns.

Two-Dimensional Array Declaration

int[ , ] x = new int [2, 3];

X is a two-dimensional array with 2 elements. And, each element is also an array

with 3 elements.
So, all together the array can store 6 elements (2 * 3).

Note: The single comma [ , ] represents the array is 2 dimensional.

Two-Dimensional Array initialization

int[ , ] x = { { 1, 2 ,3}, { 3, 4, 5 } };
X is a 2D array with two elements {1, 2, 3} and {3, 4, 5} . We can see that each
element of the array is also an array.
We can also specify the number of rows and columns during the initialization. For
example,

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

Access Elements from 2D Array

We use the index number to access elements of a 2D array. For example,

// a 2D array
int[ , ] x = { { 1, 2 ,3}, { 3, 4, 5 } };

// access first element from first row

x[0, 0]; // returns 1

// access third element from second row

x[1, 2]; // returns 5

// access third element from first row

x[0, 2]; // returns 3

Example: C# 2D Array

using System;
namespace MultiDArray {
class Program {
static void Main(string[] args) {
 //initializing 2D array
int[ , ] numbers = {{2, 3}, {4, 5}};
// access first element from the first row
Console.WriteLine("Element at index [0, 0] : "+numbers[0, 0]);
// access first element from second row
Console.WriteLine("Element at index [1, 0] : "+numbers[1, 0]);
}
}
}

using the index numbers to access elements of the 2D array.

 numbers[0, 0] - access the first element from the first row (2)
 numbers[1, 0] - access the first element from the second row (4)

Change Array Elements

We can also change the elements of a two-dimensional array. To change the element,
we simply assign a new value to that particular index. For example,

using System;

namespace MultiDArray {
class Program {
static void Main(string[] args) {

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

// old element
Console.WriteLine("Old element at index [0, 0] : "+numbers[0, 0]);

// assigning new value

numbers[0, 0] = 222;

// new element
Console.WriteLine("New element at index [0, 0] : "+numbers[0, 0]);
}
}
}
 Iterating C# Array using Loop

using System;

namespace MultiDArray {
class Program {
static void Main(string[] args) {

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

for(int i = 0; i < numbers.GetLength(0); i++) {

Console.Write("Row "+ i+": ");

for(int j = 0; j < numbers.GetLength(1); j++) {

Console.Write(numbers[i, j]+" ");

}
Console.WriteLine();

}
}
}
}

In the above example, we have used a nested for loop to iterate through the elements
of a 2D array.
 numbers.GetLength(0) - gives the number of rows in a 2D array
 numbers.GetLength(1) - gives the number of elements in the row

Note: We can also create a 3D array. Technically, a 3D array is an array that has
multiple two-dimensional arrays as its elements. For example,

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

Here, [ , , ] (2 commas) denotes the 3D array.