Single-Dimensional Arrays

{ "Auto", "SUV 4x4", "Motorcycle", "Motorhome", "Snowmobile", "Boat"};

{ 000001, 001122, 002233, 003344, 004455, 005566};

{ 104.99, 105.99, 106.99, 107.99, 108.99, 109.99};

Now that we have the concept of an array being a collection, a container, or a store for items of the same data type, we can look at how to code the implementation of an array. Like many things in life, we have choices. So C# gives us choices, different techniques, that allow us to set up and use arrays.

Choice 2: Declaring and Creating an Array in One Stage

In C#, the single-dimensional arrays we have just considered can be declared and created in one stage as

Declaration		Creation
string[]  insuranceTypes	=	new string[6];
int[]  accountNumber	=	new int[6];
double[]  insurancePremiums	=	new double[6];

In each line of code, we are

• Declaring the data type of the array – string, int, or double

• Stating that the array is single dimensional – this is the [ ] part

• Giving the array its name – insuranceTypes, accountNumber, or insurancePremiums

• Instantiating the array with the new keyword

• Stating that it will contain six elements

The statement

string[] insuranceTypes = new string[6];

creates an array that can hold six strings and sets the array name as insuranceTypes. The newly created array is automatically filled with nulls. In C#, a newly created array is always filled with the default value as shown in Table 11-4.

Table 11-4

Default values for the types used with arrays

Value type	Default value
bool	false
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0D
char	''
decimal	0.0M
sbyte	0
uint	0
ulong	0
ushort	0
String	null

The statement

int[] accountNumber = new int[6];

creates an array that can hold six integer values and sets the array name as accountNumber. The newly created array is automatically filled with zeros, as shown in Figure 11-1.

A screenshot depicts an array named account Number with 6 values for the data type 'int'. The default value for the data type int is 0.

The statement

double[] accountNumber = new double[6];

creates an array that can hold six double values and sets the array name as accountNumber. The newly created array is automatically filled with 0 values as shown in Figure 11-2.

A screenshot depicts an array named account Number with 6 values for the data type 'double'. The default value for the data type double is 0.

foreach Loop

A screenshot depicts a console screen with questions and inputs for iteration 1. The questions are about the number of claims, repair shop i d, vehicle policy number, claim amount, and repair date.

A screenshot depicts a console screen with questions and input for iteration 2. The questions are about repair shop i d, vehicle policy number, claim amount, and repair date.

The number of claims entered is 2, and this is all that the user requested, so the do while loop is complete, as shown in Figure 11-4, and the next lines of code are the foreach iteration. As a result of the foreach iteration, the console will display all the items in the array as shown in Figure 11-5.

A screenshot depicts a console screen with 8 array items fetched from the 2 iterations.

Now that we have the basics of an array, we can now explore arrays further and see some of the possible errors associated with them.

We should note that as we have not initialized the numberOfEntriesBeingMade variable, we get an error as shown in Figure 11-6.

A screenshot depicts an error that a variable name, 'number of entries being made', is not initialized.

The error message shown in Figure 11-6 is saying that we cannot use an unassigned variable for the array size. So we will simply add a line of code that will ask the user to input the number of entries they are going to make and assign this value to the variable. Now the program will be happy as it will have a value for the variable – the variable is not unassigned. What we can see is that even though the actual value of the variable is not known, the program is happy as it will know the value before the array is created.

Great, the red underline has disappeared, and the compiler is happy. So now we know that we must tell the compiler the size of the array to make it happy. We can use a variable, but this must be known when the array is declared and created.

Figure 11-7 shows the two iterations, and Figure 11-8 shows the array items.

A screenshot depicts a console screen with questions and inputs of 2 iterations. The questions are about vehicle policy number and odometer reading.

A screenshot depicts a console screen with 4 array items fetched from the 2 iterations.

IndexOutOfBounds Exception

An array is of fixed size, and if we try to read or write a value that is outside the boundary of the array, we will be causing an exception. In C# the error is known as an IndexOutOfBounds exception because it happens when we have made the value of the index, the counter, larger than the size of the array. Remember that the index starts at 0, not 1.

We will now make the iteration go one more than it currently does, by adding 1 to the Boolean condition at the end of the do while construct.

1. 31.

   Amend the code, as in Listing 11-24, to add 1 to the end of the do while.

    

  /* Increment the loop counter by 1 */

  numberOfEntriesEntered++;

} while(numberOfEntriesEntered < numberOfEntriesBeingMade + 1);

Listing 11-24

Adding +1 to the end of the do while loop

1. 32.

   Click the File menu.

    
2. 33.

   Choose Save All.

    
3. 34.

   Click the Debug menu.

    
4. 35.

   Choose Start Without Debugging.

    
5. 36.

   Type 2 for the number of entries to be made.

    
6. 37.

   Press the Enter key.

    
7. 38.

   Type VP000001 for the vehicle policy number.

    
8. 39.

   Press the Enter key.

    

The console will now ask the user to input the vehicle odometer reading.

1. 40.

   Type 10000.

    
2. 41.

   Press the Enter key.

    
3. 42.

   Type VP000002 for the vehicle policy number.

    
4. 43.

   Press the Enter key.

    
5. 44.

   Type 20000.

    
6. 45.

   Press the Enter key.

    
7. 46.

   Type VP000003 for the vehicle policy number.

    
8. 47.

   Press the Enter key.

    

Our array was made to have a size of

2 entries multiplied by the 2 values in each entry = 4

This means that the positions available in the array are

odometerReadings[0]

odometerReadings[1]

odometerReadings[2]

odometerReadings[3]

Our variable is 4, and we are therefore trying to write to position

odometerReadings[4]

This means our index of 4 is out of bounds, as 3 is the maximum boundary limit. Figure 11-9 shows the resulting runtime error.

A screenshot depicts a runtime error. It is about an unhandled exception as the index was out of bounds of the array.

We will now change the test back to its original value, no +, as in Listing 11-25.

    /* Increment the loop counter by 1 */

    numberOfEntriesEntered++;

  } while(numberOfEntriesEntered < numberOfEntriesBeingMade);

Listing 11-25

Removing the +1 from the end of the do while loop

1. 48.

   Click the File menu.

    
2. 49.

   Choose Save All.

    

Ranges and Indices: C# 8 and Above

Remember the shortcut to create the Main() method is to type svm and then press the Tab key twice.

C# 8 introduced the concept of ranges to collections along with two new operators. When using ranges, we now have the index and the range, which can be used to index and slice the collection. Both index and range are part of the System namespace. When we think about what we have done so far with arrays, we have worked from the start of the zero-indexed array and never really thought about starting from the end of the array, and we use the index of the element or elements when we need access to them. Now, in C# 8 we have been given an index expression that allows us to access the collection from the end. The hat operator, ^, means “index from end,” so ^2 would give us the second element from the end. The syntax is the ^ followed by an integer value or a variable that can be converted to an integer, and we should still be aware that we can still get an IndexOutOfRange exception if we use an incorrect integer value.

the fact that we have tried to skip 12 on line 1 when there are only 4 items and take 12 on line 2 when there are only 2 items remaining does not cause an out-of-range exception. However, if the source was null, we would get a System.ArgumentNullException: Value cannot be null error.

C# 8 however changes things, and we are now able to use the new range operator, start..howmany, and we can leave out the start or the end. The .. syntax is called the range operator.

We will amend the code to iterate the array and use the index from end within the console output . In this example we use ^(employeeAndSalary.Length – (counter)), which means

Figure 11-10 shows the array has been read using the ^ operator. We see the index from end value and the value stored at that position.

A screenshot depicts a console screen with 6 values. The screen displays the names of 3 employees and their salaries based on hat operator and index from the end expression.

The console will show the array elements as shown in Figure 11-11. We see the output line repeated as we have used the traditional method and the equivalent ^, index from end.

A screenshot depicts a console screen with array elements based on index and hat operator. The output line is repeated twice.

Figure 11-12 shows the console with the last item of the array.

A screenshot depicts a console screen that displays the last item of an array using the length property and hat operator. The output line is repeated twice.

Range

In this code we will look at the traditional method GetRange(), from the LINQ library, to get a sequence of values from the array. We will also use the Skip() and Take() methods, which are also from the LINQ library. We will then use the new range operator .. to locate elements.

We will amend the code to use the ToList() and GetRange() methods to display the items from the list within the given range. Read the comments to help with understanding the code.

1. 30.

   Amend the code as in Listing 11-30.

    

      Console.WriteLine($"The last item of the array " +

        $"is {employeeAndSalary[^1]}");

      Console.WriteLine();

      /*

      Using the range feature. Range represents a sub range of

      a sequence. A range specifies the start and end of a range.

      Ranges are exclusive, meaning the end isn't included in

      the range. The range [0..^0] represents the entire range.

      Equally [0..sequence.Length] represents the entire range.

      In the first example we use the traditional method to find

      the length. In the second example we use the indices to

      find the last item

      */

      Console.WriteLine(" GetRange and ToList *");

      Console.WriteLine("Range represents a sub range of a sequence");

      var employees = employeeAndSalary.ToList().GetRange(2, 4);

      foreach (var item in employees)

      {

        Console.WriteLine($"After using GetRange() the array item is {item}");

      }

      Console.WriteLine();

    } // End of Main() method

Listing 11-30

Using the ToList() and GetRange() methods

1. 31.

   Click the File menu.

    
2. 32.

   Choose Save All.

    
3. 33.

   Click the Debug menu.

    
4. 34.

   Choose Start Without Debugging.

    

Figure 11-13 shows the console displaying the array elements starting at element 2, the third item, and taking four items, which is up to element 5, the sixth item.

A screenshot depicts a console screen that lists 4 array items from elements 2 to 6 using get range and to list functions.

1. 35.

   Press the Enter key to close the console window.

    
2. 36.

   Amend the code, as in Listing 11-31, to use the Skip() and Take() methods and display the items.

    

      Console.WriteLine();

      Console.WriteLine("* Skip and Take * ");

      /*

      Using the skip and take features.

      In the first example we use the traditional method to

      find the length. In the second example we use the indices

      to find the last item

      */

      var someemployees = employeeAndSalary.Skip(2).Take(4);

      foreach (var item in someemployees)

      {

        Console.WriteLine($"After using Skip() and Take() the array item is {item}");

      }

      Console.WriteLine();

    } // End of Main() method

  } // End of IndicesAndRanges class

} // End of Chapter11 namespace

Listing 11-31

Using the Skip() and Take() methods

1. 37.

   Click the File menu.

    
2. 38.

   Choose Save All.

    
3. 39.

   Click the Debug menu.

    
4. 40.

   Choose Start Without Debugging.

    

The console, as shown in Figure 11-14, will show the array elements.

A screenshot depicts a console screen that lists 4 array items from elements 2 to 6 using skip and take functions.

1. 41.

   Amend the code to use the range operator and display the items.

    

      foreach (var item in someemployees)

      {

        Console.WriteLine($"After using Skip() and " +

          $"Take() the array item is {item}");

      }

      Console.WriteLine();

      Console.WriteLine("* Range operator *");

      /*

      Using the range operator .., specifies the start and end

      of a range as its operands. A range specifies the start

      and end of a range. Ranges are exclusive, meaning the

      end isn't included in the range.

      The range [0..^0] represents the entire range.

      In this example we use start at index 2 and

      stop at the element 2 from the end

      */

      var someemployeeswithindices = employeeAndSalary[2..^2];

      foreach (var item in someemployeeswithindices)

      {

        Console.WriteLine($"Starting at index 2 and stopping at the element before 2 from the end the array item is { item }");

      }

    } // End of Main() method

Listing 11-32

Using the range operator [2..^2]

1. 42.

   Click the File menu.

    
2. 43.

   Choose Save All.

    
3. 44.

   Click the Debug menu.

    
4. 45.

   Choose Start Without Debugging.

    

The console, as shown in Figure 11-15, shows the result from using the range operator.

A screenshot depicts a console screen that lists 2 array elements using range operator. The range starts from index 2 and stops at element 2 from the end.