Array Declaration

An array is declared by defining the type of the elements inside the array followed by empty brackets and a variable name; for example, an array containing integer elements is declared like this:

int[] myArray;

Array Initialization

After declaring an array, memory must be allocated to hold all the elements of the array. An array is a reference type, so memory on the heap must be allocated. This is done by initializing the variable of the array using the new operator with the type and the number of elements inside the array. Here you specify the size of the array.

myArray = new int[4];

With this declaration and initialization, the variable myArray references four integer values that are allocated on the managed heap (see Figure 5-1).

Figure 5-1

Instead of using a separate line for the declaration and initialization, you can declare and initialize an array in a single line:

int[] myArray = new int[4];

You can also assign values to every array element using an array initializer. Array initializers can only be used while declaring an array variable, not after the array is declared.

int[] myArray = new int[4] {4, 7, 11, 2};

If you initialize the array using curly brackets, the size of the array can also be left out, as the compiler can count the number of elements itself:

int[] myArray = new int[] {4, 7, 11, 2};

There’s even a shorter form using the C# compiler. Using curly brackets you can write the array declaration and initialization. The code generated from the compiler as the same as in the previous example.

int[] myArray = {4, 7, 11, 2};

Accessing Array Elements

After an array is declared and initialized, you can access the array elements using an indexer. Arrays only support indexers that have integer parameters.

With the indexer, you pass the element number to access the array. The indexer always starts with a value of 0 for the first element. The highest number you can pass to the indexer is the number of elements minus one, since the index starts at zero. In the following example, the array myArray is declared and initialized with four integer values. The elements can be accessed with indexer values 0, 1, 2 and 3.

int[] myArray = new int[] {4, 7, 11, 2};
int v1 = myArray[0];  // read first element
int v2 = myArray[1];  // read second element
myArray[3] = 44;      // change fourth element

If you don’t know the number of elements in the array, you can use the Length property that is used in this for statement:

for (int i = 0; i < myArray.Length; i++)
{
   Console.WriteLine(myArray[i]);
}

Instead of using a for statement to iterate through all elements of the array, you can also use the foreach statement.

foreach (int val in myArray)
{
   Console.WriteLine(val);
}

Using Reference Types

You cannot only declare arrays of predefined types; you can also declare arrays of a type of a custom class. Let’s start with this Person class with two constructors, the properties Firstname and Lastname, and an override of the ToString() method:

public class Person
{
   public Person()
   {
   }

   public Person(string firstname, string lastname)
   {
      this.firstname = firstname;
      this.lastname = lastname;
   }

   private string firstname;

   public string Firstname
   {
      get { return firstname; }
      set { firstname = value; }
   }

   private string lastname;

   public string Lastname
   {
      get { return lastname; }
      set { lastname = value; }
   }

   public override string ToString()
   {
      return firstname + " " + lastname;
   }
}

Declaring an array of two Person elements is similar to declaring an array of int:

Person[] myPersons = new Person[2];

However, you must be aware that if the elements in the array are reference types, memory must be allocated for every array element. In case you use an item in the array where no memory was allocated, a NullReferenceException is thrown.

You can allocate every element of the array by using an indexer starting from 0:

myPersons[0] = new Person("Ayrton", "Senna");
myPersons[1] = new Person("Michael", "Schumacher");

Figure 5-2 shows the objects in the managed heap with the Person array. myPersons is a variable that is stored on the stack. This variable references an array of Person elements that is stored on the managed heap. This array has enough space for two references. Every item in the array references a Person object that is also stored in the managed heap.

Figure 5-2

As you’ve seen it with the int type, you can also use an array initializer with custom types:

Person[] myPersons = { new Person("Ayrton", "Senna"),
                       new Person("Michael", "Schumacher") };