Defining Enumerations

You can use the enum keyword to define enumerations as follows:

enum <typeName>
{
   <value1>,
   <value2>,
   <value3>,
   …
   <valueN>
}

Next, you can declare variables of this new type as follows:

<typeName> <varName>;

You can assign values using the following:

<varName> = <typeName>.<value>;

Enumerations have an underlying type used for storage. Each of the values that an enumeration type can take is stored as a value of this underlying type, which by default is int. You can specify a different underlying type by adding the type to the enumeration declaration:

enum <typeName> : <underlyingType>
{
   <value1>,
   <value2>,
   <value3>,
   …
   <valueN>
}

Enumerations can have underlying types of byte, sbyte, short, ushort, int, uint, long, and ulong.

By default, each value is assigned a corresponding underlying type value automatically according to the order in which it is defined, starting from zero. This means that <value1> gets the value 0, <value2> gets 1, <value3> gets 2, and so on. You can override this assignment by using the = operator and specifying actual values for each enumeration value:

enum <typeName> : <underlyingType>
{
   <value1> = <actualVal1>,
   <value2> = <actualVal2>,
   <value3> = <actualVal3>,
   …
   <valueN> = <actualValN>
}

In addition, you can specify identical values for multiple enumeration values by using one value as the underlying value of another:

enum <typeName> : <underlyingType>
{
   <value1> = <actualVal1>,
   <value2> = <value1>,
   <value3>,
   …
   <valueN> = <actualValN>
}

Any values left unassigned are given an underlying value automatically, whereby the values used are in a sequence starting from 1 greater than the last explicitly declared one. In the preceding code, for example, <value3> will get the value <value1> + 1.

Note that this can cause problems, with values specified after a definition such as <value2> = <value1> being identical to other values. For example, in the following code <value4> will have the same value as <value2>:

enum <typeName> : <underlyingType>
{
   <value1> = <actualVal1>,
   <value2>,
   <value3> = <value1>,
   <value4>,
   …
   <valueN> = <actualValN>
}

Of course, if this is the behavior you want, then this code is fine. Note also that assigning values in a circular fashion will cause an error:

enum <typeName> : <underlyingType>
{
   <value1> = <value2>,
   <value2> = <value1>
}

The following Try It Out shows an example of all of this. The code defines and then uses an enumeration called orientation.

Defining Structs

Structs are defined using the struct keyword as follows:

struct <typeName>
{
   <memberDeclarations>
}

The <memberDeclarations> section contains declarations of variables (called the data members of the struct) in almost the same format as usual. Each member declaration takes the following form:

<accessibility> <type> <name>;

To allow the code that calls the struct to access the struct's data members, you use the keyword public for <accessibility>. For example:

struct route
{
   public orientation direction;
   public double      distance;
}

Once you have a struct type defined, you use it by defining variables of the new type:

route myRoute;

In addition, you have access to the data members of this composite variable via the period character:

myRoute.direction = orientation.north;
myRoute.distance  = 2.5;

This is demonstrated in the following Try It Out, where the orientation enumeration from the last Try It Out is used with the route struct shown earlier. This struct is then manipulated in code to give you a feel for how structs work.

Declaring Arrays

Arrays are declared in the following way:

<baseType>[] <name>;

Here, <baseType> may be any variable type, including the enumeration and struct types you've seen in this chapter. Arrays must be initialized before you have access to them. You can't just access or assign values to the array elements like this:

int[] myIntArray;
myIntArray[10] = 5;

Arrays can be initialized in two ways. You can either specify the complete contents of the array in a literal form or specify the size of the array and use the new keyword to initialize all array elements.

Specifying an array using literal values simply involves providing a comma-separated list of element values enclosed in curly braces:

int[] myIntArray = { 5, 9, 10, 2, 99 };

Here, myIntArray has five elements, each with an assigned integer value.

The other method requires the following syntax:

int[] myIntArray = new int[5];

Here, you use the new keyword to explicitly initialize the array, and a constant value to define the size. This method results in all the array members being assigned a default value, which is 0 for numeric types. You can also use nonconstant variables for this initialization:

int[] myIntArray = new int[arraySize];

In addition, you can combine these two methods of initialization if you want:

int[] myIntArray = new int[5] { 5, 9, 10, 2, 99 };

With this method the sizes must match. You can't, for example, write the following:

int[] myIntArray = new int[10] { 5, 9, 10, 2, 99 };

Here, the array is defined as having 10 members, but only five are defined, so compilation will fail. A side effect of this is that if you define the size using a variable, then that variable must be a constant:

const int arraySize = 5;
int[] myIntArray = new int[arraySize] { 5, 9, 10, 2, 99 };

If you omit the const keyword, this code will fail.

As with other variable types, there is no need to initialize an array on the same line that you declare it. The following is perfectly legal:

int[] myIntArray;
myIntArray = new int[5];

In the following Try It Out you create and use an array of strings, using the example from the introduction to this section.

foreach Loops

A foreach loop enables you to address each element in an array using this simple syntax:

foreach (<baseType> <name> in <array>)
{
   // can use <name> for each element
}

This loop will cycle through each element, placing it in the variable <name> in turn, without danger of accessing illegal elements. You don't have to worry about how many elements are in the array, and you can be sure that you'll get to use each one in the loop. Using this approach, you can modify the code in the last example as follows:

static void Main(string[] args)
{
   string[] friendNames = { "Todd Anthony", "Kevin Holton",
                            "Shane Laigle" };
   WriteLine($"Here are {friendNames.Length} of my friends:");
   foreach (string friendName in friendNames)
   {
      WriteLine(friendName);
   }
   ReadKey();
}

The output of this code will be exactly the same as that of the previous Try It Out. The main difference between using this method and a standard for loop is that foreach gives you read-only access to the array contents, so you can't change the values of any of the elements. You couldn't, for example, do the following:

foreach (string friendName in friendNames)
{
   friendName = "Rupert the bear";
}

If you try this, compilation will fail. If you use a simple for loop, however, you can assign values to array elements.

Multidimensional Arrays

A multidimensional array is simply one that uses multiple indices to access its elements. For example, suppose you want to plot the height of a hill against the position measured. You might specify a position using two coordinates, x and y. You want to use these two coordinates as indices, such that an array called hillHeight would store the height at each pair of coordinates. This involves using multidimensional arrays.

A two-dimensional array such as this is declared as follows:

<baseType>[,] <name>;

Arrays of more dimensions simply require more commas:

<baseType>[,,,] <name>;

This would declare a four-dimensional array. Assigning values also uses a similar syntax, with commas separating sizes. Declaring and initializing the two-dimensional array hillHeight, with a base type of double, an x size of 3, and a y size of 4 requires the following:

double[,] hillHeight = new double[3,4];

Alternatively, you can use literal values for initial assignment. Here, you use nested blocks of curly braces, separated by commas:

double[,] hillHeight = { { 1, 2, 3, 4 }, { 2, 3, 4, 5 }, { 3, 4, 5, 6 } };

This array has the same dimensions as the previous one — that is, three rows and four columns. By providing literal values, these dimensions are defined implicitly.

To access individual elements of a multidimensional array, you simply specify the indices separated by commas:

hillHeight[2,1]

You can then manipulate this element just as you can other elements. This expression will access the second element of the third nested array as defined previously (the value will be 4). Remember that you start counting from 0 and that the first number is the nested array. In other words, the first number specifies the pair of curly braces, and the second number specifies the element within that pair of braces. You can represent this array visually, as shown in Figure 5.10.

The foreach loop gives you access to all elements in a multidimensional way, just as with single-dimensional arrays:

double[,] hillHeight = { { 1, 2, 3, 4 }, { 2, 3, 4, 5 }, { 3, 4, 5, 6 } };
foreach (double height in hillHeight)
{
   WriteLine("{0}", height);
}

The order in which the elements are output is the same as the order used to assign literal values. This sequence is as follows (the element identifiers are shown here rather than the actual values):

hillHeight[0,0]
hillHeight[0,1]
hillHeight[0,2]
hillHeight[0,3]
hillHeight[1,0]
hillHeight[1,1]
hillHeight[1,2]
…

Arrays of Arrays

Multidimensional arrays, as discussed in the last section, are said to be rectangular because each “row” is the same size. Using the last example, you can have a y coordinate of 0 to 3 for any of the possible x coordinates.

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. You could also have arrays of arrays of arrays, or even more complex situations. However, all this is possible only if the arrays have the same base type.

The syntax for declaring arrays of arrays involves specifying multiple sets of square brackets in the declaration of the array, as shown here:

int[][] jaggedIntArray;

Unfortunately, initializing arrays such as this isn't as simple as initializing multidimensional arrays. You can't, for example, follow the preceding declaration with this:

jaggedIntArray = new int[3][4];

Even if you could do this, it wouldn't be that useful because you can achieve the same effect with simple multidimensional arrays with less effort. Nor can you use code such as this:

jaggedIntArray = { { 1, 2, 3 }, { 1 }, { 1, 2 } };

You have two options. You can initialize the array that contains other arrays (let's call these sub-arrays for clarity) and then initialize the sub-arrays in turn:

jaggedIntArray = new int[2][];
jaggedIntArray[0] = new int[3];
jaggedIntArray[1] = new int[4];

Alternatively, you can use a modified form of the preceding literal assignment:

jaggedIntArray = new int[3][] { new int[] { 1, 2, 3 }, new int[] { 1 },
                                new int[] { 1, 2 } };

This can be simplified if the array is initialized on the same line as it is declared, as follows:

int[][] jaggedIntArray = { new int[] { 1, 2, 3 }, new int[] { 1 },
                           new int[] { 1, 2 } };

You can use foreach loops with jagged arrays, but you often need to nest these to get to the actual data. For example, suppose you have the following jagged array that contains 10 arrays, each of which contains an array of integers that are divisors of an integer between 1 and 10:

int[][] divisors1To10 = { new int[] { 1 },
                          new int[] { 1, 2 },
                          new int[] { 1, 3 },
                          new int[] { 1, 2, 4 },
                          new int[] { 1, 5 },
                          new int[] { 1, 2, 3, 6 },
                          new int[] { 1, 7 },
                          new int[] { 1, 2, 4, 8 },
                          new int[] { 1, 3, 9 },
                          new int[] { 1, 2, 5, 10 } };

The following code will fail:

foreach (int divisor in divisors1To10)
{
   WriteLine(divisor);
}

The failure occurs because the array divisors1To10 contains int[] elements, not int elements. Instead, you have to loop through every sub-array, as well as through the array itself:

foreach (int[] divisorsOfInt in divisors1To10)
{
   foreach(int divisor in divisorsOfInt)
   {
      WriteLine(divisor);
   }
}

As you can see, the syntax for using jagged arrays can quickly become complex! In most cases, it is easier to use rectangular arrays or a simpler storage method. Nonetheless, there may well be situations in which you are forced to use this method, and a working knowledge can't hurt. An example of this happens when working with XML documents where some elements have sub-children and other do not.