Chapter 10 Using Arrays and Collections |
189 |
Generally, it is best to avoid mixing types and hoping that the compiler will convert them for you.
Implicitly typed arrays are most useful when you are working with anonymous types, described in Chapter 7, “Creating and Managing Classes and Objects.” The following code creates an array of anonymous objects, each containing two fields specifying the name and age of the members of my family (yes, I am younger than my wife):
var names = new[] { new { Name = “John”, Age = 42 }, new { Name = “Diana”, Age = 43 }, new { Name = “James”, Age = 15 },
new { Name = “Francesca”, Age = 13 } };
The fields in the anonymous types must be the same for each element of the array.
Accessing an Individual Array Element
To access an individual array element, you must provide an index indicating which element you require. For example, you can read the contents of element 2 of the pins array into an int
variable by using the following code:
int myPin; myPin = pins[2];
Similarly, you can change the contents of an array by assigning a value to an indexed element:
myPin = 1645; pins[2] = myPin;
Array indexes are zero-based. The initial element of an array lives at index 0 and not index 1. An index value of 1 accesses the second element.
All array element access is bounds-checked. If you specify an index that is less
than 0 or greater than or equal to the length of the array, the compiler throws an
IndexOutOfRangeException, as in this example:
try
{
int[] pins = { 9, 3, 7, 2 };
Console.WriteLine(pins[4]); // error, the 4th and last element is at index 3
}
catch (IndexOutOfRangeException ex)
{
...
}
190 Part II Understanding the C# Language
Iterating Through an Array
Arrays have a number of useful built-in properties and methods. (All arrays inherit methods and properties from the System.Array class in the Microsoft .NET Framework.) You can examine the Length property to discover how many elements an array contains and iterate
through all the elements of an array by using a for statement. The following sample code writes the array element values of the pins array to the console:
int[] pins = { 9, 3, 7, 2 };
for (int index = 0; index < pins.Length; index++)
{
int pin = pins[index]; Console.WriteLine(pin);
}
Note Length is a property and not a method, which is why there are no parentheses when you call it. You will learn about properties in Chapter 15, “Implementing Properties to Access Fields.”
It is common for new programmers to forget that arrays start at element 0 and that the last element is numbered Length – 1. C# provides the foreach statement to enable you to iterate
through the elements of an array without worrying about these issues. For example, here’s the preceding for statement rewritten as an equivalent foreach statement:
int[] pins = { 9, 3, 7, 2 }; foreach (int pin in pins)
{
Console.WriteLine(pin);
}
The foreach statement declares an iteration variable (in this example, int pin) that automati-
cally acquires the value of each element in the array. The type of this variable must match the type of the elements in the array. The foreach statement is the preferred way to iter-
ate through an array; it expresses the intention of the code directly, and all of the for loop scaffolding drops away. However, in a few cases, you’ll find that you have to revert to a for statement:
A foreach statement always iterates through the whole array. If you want to iterate through only a known portion of an array (for example, the first half) or to bypass certain elements (for example, every third element), it’s easier to use a for statement.
A foreach statement always iterates from index 0 through index Length – 1. If you want to iterate backward, it’s easier to use a for statement.
If the body of the loop needs to know the index of the element rather than just the value of the element, you’ll have to use a for statement.
Chapter 10 Using Arrays and Collections |
191 |
If you need to modify the elements of the array, you’ll have to use a for statement. This is because the iteration variable of the foreach statement is a read-only copy of each element of the array.
You can declare the iteration variable as a var and let the C# compiler work out the type of the variable from the type of the elements in the array. This is especially useful if you don’t actually know the type of the elements in the array, such as when the array contains anonymous objects. The following example demonstrates how you can iterate through the array of family members shown earlier:
var names = new[] { new { Name = “John”, Age = 42 }, new { Name = “Diana”, Age = 43 }, new { Name = “James”, Age = 15 },
new { Name = “Francesca”, Age = 13 } }; foreach (var familyMember in names)
{
Console.WriteLine(“Name: {0}, Age: {1}”, familyMember.Name, familyMember.Age);
}
Copying Arrays
Arrays are reference types. (Remember that an array is an instance of the System.Array class.) An array variable contains a reference to an array instance. This means that when you copy an array variable, you end up with two references to the same array instance—for example:
int[] pins = { 9, 3, 7, 2 };
int[] alias = pins; // alias and pins refer to the same array instance
In this example, if you modify the value at pins[1], the change will also be visible by reading alias[1].
If you want to make a copy of the array instance (the data on the heap) that an array variable refers to, you have to do two things. First you need to create a new array instance of the same type and the same length as the array you are copying, as in this example:
int[] pins = { 9, 3, 7, 2 }; int[] copy = new int[4];
This works, but if you later modify the code to change the length of the original array, you
must remember to also change the size of the copy. It’s better to determine the length of an array by using its Length property, as shown in this example:
int[] pins = { 9, 3, 7, 2 }; int[] copy = new int[pins.Length];
The values inside copy are now all initialized to their default value, 0.