The Array Class

An array is a technique of storing information of different items in a common variable of one name. For example, consider the following list:

This type of list can be created using a string-based array. Here is an example:

private void Form1_Load(object sender, System.EventArgs e)
{
	string[] lstItemsNames = { "Women Coat", "Men Jacket", "Teen Jeans",
			 "Women Bathing Suit", "Children Playground Dress" };
}

The above type of list is referred to as a single-dimensional. To provide more information about items, you can associate a second or even a third list to the first as follows:

private void Form1_Load(object sender, System.EventArgs e)
{
	string[] itemsNumbers = { "624376", "274952", "497852", "749752", "394085" };
	string[] lstItemsNames    = { "Women Coat", "Men Jacket", "Teen Jeans",
				"Women Bathing Suit", "Children Playground Dress" };
	double[] itemsPrices      = { 225.55, 175.75, 24.50, 34.65, 75.05 };
}

To support arrays, the .NET Framework provides the Array class, which is defined in the System namespace. Based on this, you can formally use the Array class to create an array. To support the creation of an array, the Array class is equipped with the CreateInstance() method that comes in various versions. To create a one-dimensional array, you can use the following version:

public static Array CreateInstance(Type elementType, int length);

The first argument is used to specify the type of array you want to create. Since it is declared as Type, you can use the typeof operator to cast your type.

The second argument specifies the number of items of the list. The items in an Array-based list use a zero-based index, meaning that the first item has an index of 0, the second has an index of 1, and so on. Using the Array class, you can create a list of the above item names as follows:

private void Form1_Load(object sender, System.EventArgs e)
{
	 Array lstItemsNames = Array.CreateInstance(typeof(string), length);
}

Creating various lists that would be later connected can be confusing and even overwhelming, as mentioned earlier.

Practical Learning: Creating a List Class

The Length of an Array

When creating an array that you are not initializing, you must provide the number of items that the list will contain. This number is passed inside the variable's square brackets as a constant integer. Here is an example:

private void Form1_Load(object sender, System.EventArgs e)
{
	string[] lstItemsNames = new string[5];
}

If you create a list using the Array.CreateInstance() method using the above version, you must pass a constant integer as the second argument. Here is an example:

private void Form1_Load(object sender, System.EventArgs e)
{
	Array lstItemsNames = Array.CreateInstance(typeof(string), 5);
}

If the array exists already, to find out the number of items it contains, you can access its Length property. Alternatively, you can call the Array.GetLength() method. Its syntax is:

public int GetLength(int dimension);

For a single dimensional array as those declared above, you must pass the argument as 0. This method returns a 32-bit integer that represents the number of items in the array.

Two-Dimensional Array Creation

The type of array we declared earlier is referred to as a single-dimensional. To provide more information about items, you can associate a second or even a third list to the first as follows:

private void Form1_Load(object sender, System.EventArgs e)
{
	string[] lstItemsNames    = { "Women Coat", "Men Jacket", "Teen Jeans",
		                              "Women Bathing Suit", "Children Playground Dress" };
}

You can create a two-dimensional array by entering a comma in the square brackets of the array variable and two constant integers separated by a comma when allocating memory for the array. Here is an example:

private void Form1_Load(object sender, System.EventArgs e)
{
	string[,] lstItemsNames = new string[2,3];
}

If you want to use the Array.CreateInstance() method to create a two-dimensional array, you can use the following version:

public static Array CreateInstance(Type elementType, int length1, int length2);

A two-dimensional array is also called an array of two arrays. If using the classic technique of declaring an array, the first number specified when allocating memory, in the above example it would be 2, represents the number of arrays. This is the same number of the second argument of the current CreateInstance() method. For a two-dimensional array, this number is always 2. The second number of the classic declaration and the third argument of the current CreateInstance() method specify the number of items that each list would contain. In the above declaration, the number 3 means that each array will be made of three items.

Based on this, here is an example of declaring a two-dimensional array using the CreateInstance() method:

private void Form1_Load(object sender, System.EventArgs e)
{
	string[,] lstItemsNames = new string[2,3];
	Array lstItemsNumbers = Array.CreateInstance(typeof(string), 2, 3);
}

To know the total number of items that an array contains, you can access its Length property. To know the number of items that a particular list contains, call the Array.GetLength() method and pass the number corresponding to the array. To know the number of items in the first list, pass the argument as 0. To know the number of items in the second list, pass the argument as 1.

Besides the single or two-dimensional, you can create multidimensional arrays by specifying the number of commas in the square brackets and specifying the numbers in the right square brackets. If you want to use the Array.CreateInstance() method to create a multidimensional array, you can call the following version:

public static Array CreateInstance(Type elementType, params int[] lengths);

With this version of the method, the second argument specifies the number of arrays that the variable will hold.

If you want to find out the total number of items that an array contains, access its Length property. To get the number of items that a particular list contains, you can call the Array.GetLength() method and pass the number corresponding to the array.

To know the number of lists that an array variable contains, you can access its Rank property.

Operations on Arrays

Adding Items to an Array

There are two main techniques you can use to initialize an array. You can create its list of items when declaring the array. Here is an example:

private void Form1_Load(object sender, System.EventArgs e)
{
	double[] itemsPrices = { 225.55, 175.75, 24.50, 34.65, 75.05 };
}

Another technique is to first declare the array, then initialize each of its members. Here is an example:

private void Form1_Load(object sender, System.EventArgs e)
{
	string[] storeItems = new string[4];
				 
	storeItems[0] = "Women Coat";
	storeItems[1] = "Women Bathing Suit";
	storeItems[2] = "Quilted Down Jacket";
	storeItems[3] = "Men Jacket";
}

Here is an example for a two-dimensional array:

private void Form1_Load(object sender, System.EventArgs e)
{
	string[,] storeItems = new string[2,3];
				 
	storeItems[0,0] = "Women Coat";
	storeItems[0,1] = "Women Bathing Suit";
	storeItems[0,2] = "Quilted Down Jacket";
	storeItems[1,0] = "Men Jacket";
	storeItems[1,1] = "Children Playground Dress";
	storeItems[1,2] = "Boys Trousers";
}

The Array class also provides its own support for adding items to an array. This is done using the Array.SetValue() that is overloaded with various versions. To add a new item to a single-dimensional array, you can use the following syntax:

public void SetValue(Object value, int index);

The first argument is the value to add to the list. The second argument is the index of the item to be added. The first item has index 1; the second item has index 2, and so on. Here is an example:

private void Form1_Load(object sender, System.EventArgs e)
{
	string[] storeItems = new string[4];
				 
	storeItems.SetValue("Women Coat", 0);
	storeItems.SetValue("Women Bathing Suit", 1);
	storeItems.SetValue("Quilted Down Jacket", 2);
	storeItems.SetValue("Men Jacket", 3);
}

The Array class provides a SetValue() version for each corresponding CreateInstance() method we reviewed earlier.

Practical Learning: Adding Items to an Array

Accessing the Members of an Array

Probably the most regularly performed operation on a list consists of retrieving the values of its members. You access the member of an array using its index as we saw earlier. To perform the same operation, the Array class is equipped with the GetValue() method that is overloaded with a version corresponding to each version of the CreateInstance() and the SetValue() methods. For example, to access the values stored in a one-dimensional array, you can call call this version:

public object GetValue(int index);

The argument is the zero-based index of the member whose value you want to access. If you pass an invalid value, the computer would throw an IndexOutOfRangeException exception.

Practical Learning: Accessing the Members of an Array

The Arrangement of the List

When a new item is added to the array, it assumes the last position. If you want, you can re-arrange the list in a consecutive order. If the list is a one-dimensional array made of strings, you can arrange it in alphabetical order. If it is made of numbers, you can order them in increment or decrement order. If the list is a two, three, or multi-dimensional array, you can arrange it based on a list-part of your choice. To support the ability to re-organize the list, the Array class is equipped with the Sort() method that is overloaded with as many versions as you can possibly need.

To arrange a single-dimensional array in a consecutive order, you can call the following version of the Array.Sort() method:

public static void Sort(Array array);

To reverse the sequence of items of a one-dimensional array, you can call the Array.Reverse() method. Its syntax is:

public static void Reverse(Array array);

When using a list, you may want to know whether a particular item exists in the list. There are usually two ways to perform this operation. You usually can use a for or a foreach statement to scan a list. With this approach, you navigate through the list by visiting the index of each item and checking the value of that index. Another solution consists of writing a function to perform the search. The Array class provides its own support of both solutions using various methods that can be used to perform this operation.

The Array.IndexOf() method scans a list by accessing the index of each item. This method is overloaded with three versions. To apply it on a single-dimensional array, use the following version:

public static int IndexOf(Array array, object value);

This method visits each member of the array, looking for the value. Once it finds value in the array, it stops and returns the index where the first occurrence of value was found. The IndexOf() method actually looks for the first occurrence of an item in an array. If you prefer to get the last occurrence of that item in the array, you can call the Array.LastIndexOf() method. It also is overloaded in three versions.