Let's start with some important definitions having to do with arrays in C#.

The following are some important general facts about C# arrays:

Figure 14-1. Dimensions and sizes

To declare a one-dimensional or rectangular array, use a single set of square brackets between the type and the variable name.

The rank specifiers are commas between the brackets. They specify the number of dimensions the array will have. The rank is the number of commas, plus one. For example, no commas indicates a one-dimensional array, one comma indicates a two-dimensional array, and so forth.

The base type, together with the rank specifiers, is the type of the array. For example, the following line of code declares a one-dimensional array of longs. The type of the array is long[], which is read as "an array of longs."

The following code shows examples of declarations of rectangular arrays. Notice that

For a one-dimensional array, you can set explicit initial values by including an initialization list immediately after the array-creation expression of an array instantiation.

For example, the following code creates an array and initializes its four elements to the values between the curly braces. Figure 14-7 illustrates the layout in memory.

Figure 14-7. Explicit initialization of a one-dimensional array

To explicitly initialize a rectangular array:

For example, the following code shows the declaration of a two-dimensional array with an initialization list. Figure 14-8 illustrates the layout in memory.

Figure 14-8. Initializing a rectangular array

Rectangular arrays are initialized with nested, comma-separated initialization lists. The initialization lists are nested in curly braces. This can sometimes be confusing, so to get the nesting, grouping, and commas right, the following tips can be helpful:

For example, read the following declaration as "intArray has four groups of three groups of two elements."

When combining declaration, array creation, and initialization in a single statement, you can omit the array-creation expression part of the syntax. This shortcut syntax is shown in Figure 14-9.

Figure 14-9. Shortcut for array declaration, creation, and initialization

So far we've explicitly specified the array types at the beginnings of all our array declarations. Starting with C# 3.0, however, like other local variables, your arrays can be implicitly typed. What this means is the following:

The following code shows explicit and implicit versions of three array declarations. The first set is a one-dimensional array of ints. The second is a two-dimensional array of ints. The third is an array of strings. Notice that in the declaration of implicitly typed intArr4 you still need to include the rank specifier in the initialization.

The following code puts together all the pieces we've looked at so far. It creates, initializes, and uses a rectangular array.

// Declare, create, and initialize an implicitly typed array.
   var arr = new int[,] {{0, 1, 2}, {10, 11, 12}};

   // Print the values.
   for( int i=0; i<2; i++ )
      for( int j=0; j<3; j++ )
         Console.WriteLine("Element [{0},{1}] is {2}", i, j, arr[i,j]);

This code produces the following output:

Element [0,0] is 0
Element [0,1] is 1
Element [0,2] is 2
Element [1,0] is 10
Element [1,1] is 11
Element [1,2] is 12

The declaration syntax for jagged arrays requires a separate set of square brackets for each dimension. The number of sets of square brackets in the declaration of the array variable determines the rank of the array.

You can combine the jagged array declaration with the creation of the first-level array using an array-creation expression, such as in the following declaration. The result is shown in Figure 14-11.

Figure 14-11. Shortcut first-level instantiation

You cannot instantiate more than the first-level array in the declaration statement.

Unlike other types of arrays, you cannot fully instantiate a jagged array in a single step. Since a jagged array is an array of independent arrays—each array must be created separately. Instantiating a full jagged array requires the following steps:

For example, the following code shows the declaration, instantiation, and initialization of a two-dimensional jagged array. Notice in the code that the reference to each sub-array is assigned to an element in the top-level array. Steps 1 through 4 in the code correspond to the numbered representations in Figure 14-12.

int[][] Arr = new int[3][];                  // 1. Instantiate top level


   Arr[0] = new int[] {10, 20, 30};             // 2. Instantiate sub-array
   Arr[1] = new int[] {40, 50, 60, 70};         // 3. Instantiate sub-array
   Arr[2] = new int[] {80, 90, 100, 110, 120};  // 4. Instantiate sub-array

Figure 14-12. Creating a two-dimensional jagged array

Since the sub-arrays in a jagged array are themselves arrays, it is possible to have rectangular arrays inside jagged arrays. For example, the following code creates a jagged array of three two-dimensional rectangular arrays and initializes them with values. It then displays the values.

Figure 14-13. Jagged array of three two-dimensional arrays

Since the value of the iteration variable is read-only, clearly, it cannot be changed. But this has different effects on value type arrays and reference type arrays.

For value type arrays, this means that you cannot change the data of the array. For example, in the following code, the attempt to change the data in the iteration variable produces a compile-time error message:

int[] arr1 = {10, 11, 12, 13};

   foreach( int item in arr1 )
      item++;     // Compilation error. Changing variable value is not allowed.

For reference type arrays, you still cannot change the iteration variable, but the iteration variable only holds the reference to the data, not the data itself. You can, therefore, change the data through the iteration variable.

The following code creates an array of four MyClass objects and initializes them. In the first foreach statement, the data in each of the objects is changed. In the second foreach statement, the changed data is read from the objects.

class MyClass
   {
      public int MyField = 0;
   }

   class Program  {
      static void Main() {
         MyClass[] mcArray = new MyClass[4];            // Create array
         for (int i = 0; i < 4; i++)
         {
            mcArray[i] = new MyClass();                 // Create class objects
            mcArray[i].MyField = i;                     // Set field
         }
         foreach (MyClass item in mcArray)
            item.MyField += 10;                         // Change the data.

         foreach (MyClass item in mcArray)
            Console.WriteLine("{0}", item.MyField);     // Read the changed data.
      }
   }

This code produces the following output:

10
11
12
13

In a multidimensional array, the elements are processed in the order in which the rightmost index is incremented fastest. When the index has gone from 0 to length − 1, the next index to the left is incremented, and the indexes to the right are reset to 0.

class Program
   {
      static void Main()
      {
         int total = 0;
         int[,] arr1 = { {10, 11}, {12, 13} };


         foreach( var element in arr1 )
         {
            total += element;
            Console.WriteLine
                      ("Element: {0}, Current Total: {1}", element, total);
         }
      }
   }

Element: 10, Current Total: 10
Element: 11, Current Total: 21
Element: 12, Current Total: 33
Element: 13, Current Total: 46

class Program
   {
      static void Main( )
      {
         int total = 0;
         int[][] arr1 = new int[2][];
         arr1[0] = new int[] { 10, 11 };
         arr1[1] = new int[] { 12, 13, 14 };


         foreach (int[] array in arr1)       // Process the top level.
         {
            Console.WriteLine("Starting new array");
            foreach (int item in array)      // Process the second level.
            {
               total += item;
               Console.WriteLine("  Item: {0}, Current Total: {1}", item, total);
            }
         }
      }
   }

Starting new array
 Item: 10, Current Total: 10
 Item: 11, Current Total: 21
Starting new array
 Item: 12, Current Total: 33
 Item: 13, Current Total: 46
 Item: 14, Current Total: 60

The Clone method performs a shallow copy of an array. This means that it only creates a clone of the array itself. If it is a reference type array, it does not copy the objects referenced by the elements. This has different results for value type arrays and reference type arrays.

The Clone method returns a reference of type object, which must be cast to the array type.

For example, the following code shows an example of cloning a value type array, producing two independent arrays. Figure 14-16 illustrates the steps shown in the code.

static void Main()
   {
      int[] intArr1 = { 1, 2, 3 };                             // Step 1
      int[] intArr2 = (int[]) intArr1.Clone();                 // Step 2

      intArr2[0] = 100; intArr2[1] = 200; intArr2[2] = 300;    // Step 3
   }

Figure 14-16. Cloning a value type array produces two independent arrays.

Cloning a reference type array results in two arrays pointing at the same objects. The following code shows an example. Figure 14-17 illustrates the steps shown in the code.

class A
   {
      public int Value = 5;
   }

   class Program
   {
      static void Main()
      {
         A[] AArray1 = new A[3] { new A(), new A(), new A() };     // Step 1
         A[] AArray2 = (A[]) AArray1.Clone();                      // Step 2

         AArray2[0].Value = 100;
         AArray2[1].Value = 200;
         AArray2[2].Value = 300;                                   // Step 3
      }
   }

Figure 14-17. Cloning a reference type array produces two arrays referencing the same objects.