Arrays In C#

What is array

An array is a type that holds multiple variables of one type, allowing index access to the individual value.

An array is a series of elements of the same type placed in contiguous memory locations that can be individually referenced by adding an index to a unique identifier.

An array in .NET is created from Array base class. Array is a reference type because it is created from array class. The base class for arrays in C# is the System.Array class.

Array is fixed type. You can create array of primitive and non-primitive types. Array base address is stored in stack and array is kept in heap memory.

System.Array is the abstract base type of all array types. Array type can't be inherited. Array can't be extended. There size is fixed. Private constructor and inner class is use to create it.

Type of Arrays in C#.NET

Single-dimensional arrays
Multidimensional arrays (rectangular arrays)
Jagged Arrays (array-of-arrays)
Mixed Arrays

Single Dimensional Array

Single-dimensional arrays are the simplest form of arrays. These types of arrays are used to store number of items of a predefined type. All items in a single dimension array are stored in a row starting from 0 to the size of array - 1.

Single Dimensional array is also called one-dimensional array.

DataType[] VariableName = new DataType[Number];

In the above declaration DataType can be char, int, float, double, decimal, string, etc.

VariableName is the name of the array.

The square brackets [] on the left of the assignment operator are used to let the compiler know that you are declaring an array instead of a normal variable.

The new operator allows the compiler to reserve memory.

The [Number] factor is used to specify the number of items of the list.

Declaring single dimensional array

int[] arr = new int[10];
double numbers = new double[5];
string[] names = new string[2];

Single dimensional array initialization

int[] numbers = new int[] { 1, 2, 3, 4, 5, 6,7,8,9,10 };
string[] names = new string[] { "Rocky", "Sam", "Tina", "Yoo", "James", "Samantha" };

You can omit the size of the array, like this:

int[] numbers = new int[] {1, 2, 3, 4, 5};
string[] names = new string[] {"Reena", "Prety", "Rocky", "David");

You can also omit the new operator if you initialize array like this:

int[] numbers = {1, 2, 3, 4, 5};
string[] names = {"Reena", "Prety", "Rocky", "David"};

Practical demonstration of single dimensional array

using System;
namespace array_example1
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = new int[10];
            for (int x = 0; x < 10; x++)
            {
                Console.WriteLine("Enter array element : {0}", x + 1);
                arr[x] = Int32.Parse(Console.ReadLine());
            }
            foreach (int i in arr)
            {
                Console.WriteLine(i);
            }
            Console.ReadLine();
        }
    }
}

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.

Something about foreach

In a for loop, you should know the number of element of the array. If you don't, the C# language allows you to let the compiler use its internal mechanism to get this count and use it to know where to stop counting. To assist you with this, C# provides the foreach operator.
foreach loop is used on enumerator type only.
foreach is read-only loop.

Multidimensional arrays (rectangular arrays)

Arrays can have more than one dimension; these arrays-of-arrays are called multidimensional arrays. They are very similar to standard arrays with the exception that they have multiple sets of square brackets after the array identifier.

The most common kind of multidimensional array is the two-dimensional array. A two dimensional array can be thought of as a grid of rows and columns.

Declaring multidimensional array

string[,] names = new string[4, 4];
int[,] numbers = new int[3, 4];

Multidimensional array initialization

int[,] numbers = new int[3, 2] {{1,2}, {3,4}, {5,6}};
string[,] names = new string[2, 2] {{"Ana", "Anita"}, {"Bob", "Barbie"}};

You can omit the size of the array, like this:

int[,] numbers = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 } };
string[,] names = new string[,] {{"Ana", "Anita"}, {"Bob", "Barbie"}};

You can also omit the new operator if you initialize array like this:

int[,] numbers = {{1,2}, {3,4}, {5,6}};
string[,] names = {{"Ana", "Anita"}, {"Bob", "Barbie"}};

Practical demonstration of multidimensional array

using System;
namespace array_multidim
{
    class Program
    {
        static void Main(string[] args)
        {
            //declaring a array with 4 rows and 3 columns
            int[,] arr = new int[4, 3];
            //accepting values in the array
            for (int x = 0; x < 4; x++)
            {
                Console.WriteLine("Enter row element : {0}", x + 1);
                for (int y = 0; y < 3; y++)
                {
                    arr[x, y] = Int32.Parse(Console.ReadLine());
                }
            }
            // displaying values of multidimensional array
            for (int x = 0; x < 4; x++)
            {
                Console.WriteLine("Values of row : {0}", x + 1);
                for (int y = 0; y < 3; y++)
                {
                    Console.Write(arr[x, y] + "\t");
                }
                Console.WriteLine();
            }
            Console.ReadLine();
        }
    }
}

Jagged Arrays (array-of-arrays)

Jagged arrays are often called array of arrays. More specifically, a jagged array is an array of vectors. Unlike rectangular arrays, a jagged array, as the name implies, is jagged as each vector in the array can be of different length.

It is also possible to have jagged arrays, whereby "rows" may be different sizes. For this, you need an array in which each element is another array. However, all this is only possible if the arrays have the same base type.

Declaring and initializing jagged array.

int[][] jaggedArray = new int[2][];
jaggedArray[0] = new int[3];
jaggedArray[1] = new int[5];
jaggedArray[0] = new int[] { 3, 5, 7, };
jaggedArray[1] = new int[] { 1, 0, 2, 4, 6 };

You can also initialize the array upon declaration like this:

int[][] jaggedArray = new int[][]
{
new int[] { 3, 5, 7, },
new int[] { 1, 0, 2, 4, 6 }
};

You can use the following shorthand form:

int[][] jaggedArray =
{
new int[] { 3, 5, 7, },
new int[] { 1, 0, 2, 4, 6 }
};

Note: Notice that you cannot omit the new operator from the elements initialization because there is no default initialization for the elements.

A jagged array is an array of arrays, and therefore its elements are reference types and are initialized to null.

It is possible to mix jagged and multidimensional arrays. The following is a declaration and initialization of a single-dimensional jagged array that contains two-dimensional array elements of different sizes:

int[][,] jaggedArray = new int[4][,]
{
new int[,] { {11,23}, {58,78} },
new int[,] { {50,62}, {45,65}, {85,15} },
new int[,] { {245,365}, {385,135} },
new int[,] { {1,2}, {4,4}, {4,5} }
};

Practical demonstration of jagged array

using System;
namespace array_jagged
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declare the array of four elements:
            int[][] arr = new int[4][];
            // Initialize the elements:
            arr[0] = new int[2] { 7, 9 };
            arr[1] = new int[4] { 12, 42, 26, 38 };
            arr[2] = new int[6] { 3, 5, 7, 9, 11, 13 };
            arr[3] = new int[3] { 4, 6, 8 };
            // Display the array elements:
            for (int i = 0; i < arr.Length; i++)
            {
                System.Console.Write("Element({0}): ", i + 1);
                for (int j = 0; j < arr[i].Length; j++)
                {
                    System.Console.Write("{0}{1}", arr[i][j], j == (arr[i].Length - 1) ? "" : " ");
                }
                System.Console.WriteLine();
            }
            Console.ReadLine();
        }
    }
}

Mixed Arrays

Mixed arrays are a combination of multi-dimension arrays and jagged arrays. Multi-dimension arrays are also called as rectangular arrays.

Understanding the Array Class

Arrays are extremely useful when you have several similar objects that you want to be able to process the same way or to be able to process as a group rather than individually.

The Array class, defined in the System namespace, is the base class for arrays in C#. Array class is an abstract base class, which can't be inherited, but it provides CreateInstance method to construct an array.

System.Array class provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.

Array class properties

IsFixedSize	Return a value indicating if an array has a fixed size or not.
Length	Returns the total number of items in all the dimensions of an array
Rank	Returns the number of dimensions of an array.
SyncRoot	Returns an object that can be used to synchronize access to the array.

Array class methods

BinarySearch	This method searches a one-dimensional sorted Array for a value, using a binary search algorithm.
Clear	This method removes all items of an array and sets a range of items in the array to 0.
Clone	This method creates a shallow copy of the Array.
Copy	This method copies a section of one Array to another Array and performs type casting and boxing as required.
CopyTo	This method copies all the elements of the current one-dimensional Array to the specified one-dimensional Array starting at the specified destination Array index.
CreateInstance	This method initializes a new instance of the Array class.
GetEnumerator	This method returns an IEnumerator for the Array.
GetLength	This method returns the number of items in an Array.
GetLowerBound	This method returns the lower bound of an Array.
GetUpperBound	This method returns the upper bound of an Array.
GetValue	This method returns the value of the specified item in an Array.
IndexOf	This method returns the index of the first occurrence of a value in a one-dimensional Array or in a portion of the Array.
Initialize	This method initializes every item of the value-type Array by calling the default constructor of the value type.
LastIndexOf	This method returns the index of the last occurrence of a value in a one-dimensional Array or in a portion of the Array.
Reverse	This method reverses the order of the items in a one-dimensional Array or in a portion of the Array.
SetValue	This method sets the specified items in the current Array to the specified value.
Sort	This method sorts the items in one-dimensional Array objects.

Conclusion

Well, I hope that you've benefited, at least a little, from this array tutorial. Your feedback and constructive contributions are welcome. Please feel free to contact me for feedback or comments you may have about this article.