Introduction to Arrays in C#
An array is a list of items or collection of elements which is of same or
similar data type (homogenous elements).
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.
Create an Array in C#
Syntax
data_type [] name_of_array
Declaration of an Array:
class Name
{
static void Main(string[]args)
{
Int32[] intarray; //array declaration
}
}
Array Initialization:
class Name
{
static void Main(string[]args)
{
Int32[] Intarray; //array declaration
Intarray = new Int32[4]; // array initialization
Intarray[0]= 23; // assigning values to the elements
Intarray[1]=5;
Intarray[2]=88;
Intarray[3]=6;
}
}
Displaying values of Array:
class Name
{
static void Main(string[]args)
{
Int32[] Intarray; //array declaration
Intarray = new Int32[4]; //array initialization
Intarray[0]= 23; //assigning values to array
Intarray[1]=5;
Intarray[2]=88;
Intarray[3]=6;
Console.WriteLine(Intarray[0]);
Console.WriteLine(Intarray[1]);
Console.WriteLine(Intarray[2]);
Console.WriteLine(Intarray[3]);
Console.ReadKey();
}
}
Examples:
using System;
namespace ArrayDemo
{
class Name
{
static void Main(string[] args)
{
Int32[] Intarray; // array declaration
Intarray = new Int32[4]; // array initialization
Intarray[0] = 23; // assigning values to the array element
Intarray[1] = 5;
Intarray[2] = 88;
Intarray[3] = 6;
Console.WriteLine(Intarray[0]);
Console.WriteLine(Intarray[1]);
Console.WriteLine(Intarray[2]);
Console.WriteLine(Intarray[3]);
Console.ReadKey();
}
}
}
Example - 2:
using System;
namespace Demo
{
class Array
{
static void Main(string[] args)
{
int[] arr = new int[4] { 10, 20, 30, 40 };
for (int i = 0; i < arr.Length; i++) // Traverse array elements
{
Console.WriteLine(arr[i]);
}
}
}
}
Example - 3:
using System;
namespace Demo
{
class Array
{
static void Main(string[] args)
{
int[] arr = new int[4] { 10, 20, 30, 40 };
foreach (int i in arr)
{
Console.WriteLine(i);
}
}
}
}
Types of Array in C#:
1. Single dimension array.
2. Multi-dimension array.
3. Jagged array.
Multi-dimension Array
Multi-dimensional arrays, data is stored in tabular form. In a multidimensional array, each element of the array is
also an array.
int[ , ] x = { { 1, 2 ,3}, { 3, 4, 5 } };
Here, 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];
Here, 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 } };
Here, 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
int [ , ] x = new int[2, 3]{ {1, 2, 3}, {3, 4, 5} };
Access Elements from 2D Array
// 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:
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]);
}
}
}
Change Array Elements
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();
}
}
}
}Note:
numbers.GetLength(0) - gives the number of rows in a 2D array
numbers.GetLength(1) - gives the number of elements in the row
Example:
using System;
namespace TwoDimensionalArayDemo
{
class Program
{
static void Main(string[] args)
{
//Creating a 2D Array with 4 Rows and 5 Columns
int[,] RectangleArray = new int[4, 5];
int a = 0;
//Printing the values of 2D array using foreach loop
//It will print the default values as we are not assigning any values to the array
foreach (int i in RectangleArray)
{
Console.Write(i + " ");
}
Console.WriteLine("\n");
//Assigning values to the 2D array by using nested for loop
for (int i = 0; i < RectangleArray.GetLength(0); i++)
{
for (int j = 0; j < RectangleArray.GetLength(1); j++)
{
a += 5;
RectangleArray[i, j] = a;
}
}
for (int i = 0; i < RectangleArray.GetLength(0); i++)
{
for (int j = 0; j < RectangleArray.GetLength(1); j++)
{
Console.Write(RectangleArray[i, j] + " ");
}
}
Console.ReadKey();
}
}
}
2D Array Declaration and Initialization at the Same Statement:
using System;
namespace TwoDimensionalArayDemo
{
class Program
{
static void Main(string[] args)
{
//Assigning the Array Elements at the time of declaration
//Row Size: 3
//Column Size: 4
int[,] NumbersArray = {{11,12,13,14},{21,22,23,24},{31,32,33,34}};
//Printing Array Elements using for each loop
Console.WriteLine("Printing Array Elements using ForEach loop");
foreach (int i in NumbersArray)
{
Console.Write(i + " ");
}
//Printing Array Elements using nested for each
Console.WriteLine("\n\nPrinting Array Elements using Nested For Loop");
for (int i = 0; i < NumbersArray.GetLength(0); i++)
{
for (int j = 0; j < NumbersArray.GetLength(1); j++)
{
Console.Write(NumbersArray[i, j] + " ");
}
}
Console.ReadKey();
}
}
}
Program to Add 2 Matrices using C#:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Addmatrices
{
class Program
{
static void Main(string[] args)
{
int i, j, n;
int[,] arr1 = new int[50, 50];
int[,] brr1 = new int[50, 50];
int[,] crr1 = new int[50, 50];
Console.Write("\n\naddition of two Matrices :\n");
Console.Write("-----------------------------------------\n");
Console.Write("Input the size of the square matrix (less than 5): ");
n = Convert.ToInt32(Console.ReadLine());
/* Stored values into the array*/
Console.Write("Input elements in the first matrix :\n");
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
Console.Write("element - [{0},{1}] : ", i, j);
arr1[i, j] = Convert.ToInt32(Console.ReadLine());
}
}
Console.Write("Input elements in the second matrix :\n");
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
Console.Write("element - [{0},{1}] : ", i, j);
brr1[i, j] = Convert.ToInt32(Console.ReadLine());
}
}
Console.Write("\nThe First matrix is :\n");
for (i = 0; i < n; i++)
{
Console.Write("\n");
for (j = 0; j < n; j++)
Console.Write("{0}\t", arr1[i, j]);
}
Console.Write("\nThe Second matrix is :\n");
for (i = 0; i < n; i++)
{
Console.Write("\n");
for (j = 0; j < n; j++)
Console.Write("{0}\t", brr1[i, j]);
}
/* calculate the sum of the matrix */
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
crr1[i, j] = arr1[i, j] + brr1[i, j];
Console.Write("\nThe Addition of two matrix is : \n");
for (i = 0; i < n; i++)
{
Console.Write("\n");
for (j = 0; j < n; j++)
Console.Write("{0}\t", crr1[i, j]);
}
Console.Write("\n\n");
Console.ReadKey();
}
} }
C# Jagged Arrays
A jagged array in C# is an array of arrays, where each sub-array can have a different length. This
makes jagged arrays very flexible, allowing you to store and manipulate data of varying sizes and
dimensions.
Here's an example of a jagged array in C# that stores the grades of a classroom of students:
int[][] grades = new int[3][];
grades[0] = new int[] { 85, 76, 90, 89 };
grades[1] = new int[] { 92, 88, 94 };
grades[2] = new int[] { 75, 80, 82, 77, 90 };
In this example, we've created a jagged array grades with three sub-arrays. The first sub-array
contains four grades, the second sub-array contains three grades, and the third sub-array contains
five grades. Notice that we didn't have to specify the length of each sub-array when we declared the
grades array; instead, we created each sub-array separately and assigned it to the appropriate
element of the grades array.
To access an element in a jagged array, you need to use two sets of square brackets. The first set of
brackets specifies the index of the sub-array you want to access, and the second set of brackets
specifies the index of the element within that sub-array.
For example, to access the grade 76 in the first sub-array of the grades array, you would use the
following code:
int x = grades[0][1];
Jagged arrays can be useful in a variety of situations, such as storing data from a database query or
representing a grid of values where each row may have a different number of columns. They also have
the advantage of being more memory-efficient than multidimensional arrays, since they only allocate
memory for the sub-arrays that are actually needed. However, accessing elements in a jagged array
can be slightly slower than accessing elements in a multidimensional array, since it requires an extra
level of indirection.
Introduction to String Array in C#
In C#, a string array is an array of strings, where each element of the array is a string. Here's an
example of a string array in C# that stores the names of several colors:
string[] colors = new string[] { "red", "green", "blue", "yellow" };
In this example, we've created a string array colors with four elements, each of which is a string that
represents a color. Notice that we used the new keyword to allocate memory for the array and
initialize its elements all in one step.
You can access an element in a string array by using its index, which is an integer value that
represents its position in the array. For example, to access the third element of the colors array (which
is the string "blue"), you would use the following code:
string color = colors[2];
You can also change the value of an element in a string array by assigning a new string value to it. For
example, to change the value of the second element of the colors array to "purple", you would use
the following code:
colors[1] = "purple";
C# Multidimensional Arrays
A multidimensional array in C# is an array of arrays, where each element of the array is itself an array.
A two-dimensional array, for example, is an array of rows, where each row is an array of columns.
Here's an example of a two-dimensional array in C# that stores the grades of a classroom of students:
int[,] matrix = new int[3, 4]
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 }
};
In this example, we've created a two-dimensional array matrix with 3 rows and 4 columns. Each row
represents a set of numbers and each column represents a specific value. The values of the array have
been initialized to the numbers 1 through 12.
We can access specific elements of the array using their indices like this:
int value = matrix[0, 2]; // This gets the value in row 0, column 2 (which is 3)
We can also modify elements of the array by assigning new values to them:
matrix[1, 3] = 20; // This sets the value in row 1, column 3 to 20
We can even use loops to iterate through the elements of the array and perform operations on them:
for (int i = 0; i < matrix.GetLength(0); i++)
{
for (int j = 0; j < matrix.GetLength(1); j++)
Console.Write(matrix[i, j] + " ");
Console.WriteLine();
This code uses a nested for loop to iterate through each element of the array and print its value to the
console. The GetLength method is used to get the length of each dimension of the array, which allows
us to iterate through all the elements even if we don't know the exact size of the array.
