Though arrays are fixed-length entities, you can use the static Array method Resize, which takes two arguments—the array to be resized and the new length—to create a new array with the specified length. This method copies the contents of the old array into the new array and sets the variable it receives as its first argument to reference the new array. For example, consider the following statements:

int[] newArray = new int[ 5 ];
Array.Resize( ref newArray, 10 );

The variable newArray initially refers to a five-element array. The resize method sets newArray to refer to a new 10-element array. If the new array is smaller than the old array, any content that cannot fit into the new array is truncated without warning.

The application of Fig. 8.2 uses keyword new to create an array of five int elements that are initially 0 (the default for int variables).

 1   // Fig. 8.2: InitArray.cs
 2   // Creating an array.
 3   using System;
 4
 5   public class InitArray
 6   {
 7      public static void Main( string[] args )
 8      {
 9         int[] array; // declare array named array
10
11         // create the space for array and initialize to default zeros
12         array = new int[ 5 ]; // 5 int elements
13
14         Console.WriteLine( "{0}{1,8}", "Index", "Value" ); // headings
15
16         // output each array element's value                            
17         for ( int counter = 0; counter < array.Length; counter++ )      
18            Console.WriteLine( "{0,5}{1,8}", counter, array[ counter ] );
19      } // end Main
20   } // end class InitArray

Index   Value
    0       0
    1       0
    2       0
    3       0
    4       0

Line 9 declares array—a variable capable of referring to an array of int elements. Line 12 creates the five-element array object and assigns its reference to variable array. Line 14 outputs the column headings. The first column contains the index (0–4) of each array element, and the second column contains the default value (0) of each array element right justified in a field width of 8.

The for statement in lines 17–18 outputs the index number (represented by counter) and the value (represented by array[counter]) of each array element. The loop-control variable counter is initially 0—index values start at 0, so using zero-based counting allows the loop to access every element of the array. The for statement’s loop-continuation condition uses the property array.Length (line 17) to obtain the length of the array. In this example, the length of the array is 5, so the loop continues executing as long as the value of control variable counter is less than 5. The highest index value of a five-element array is 4, so using the less-than operator in the loop-continuation condition guarantees that the loop does not attempt to access an element beyond the end of the array (i.e., during the final iteration of the loop, counter is 4). We’ll soon see what happens when an out-of-range index is encountered at execution time.

An application can create an array and initialize its elements with an array initializer, which is a comma-separated list of expressions (called an initializer list) enclosed in braces. In this case, the array length is determined by the number of elements in the initializer list. For example, the declaration

int[] n = { 10, 20, 30, 40, 50 };

creates a five-element array with index values 0, 1, 2, 3 and 4. Element n[0] is initialized to 10, n[1] is initialized to 20 and so on. This statement does not require new to create the array object. When the compiler encounters an array initializer list, it counts the number of initializers in the list to determine the array’s size, then sets up the appropriate new operation “behind the scenes.” The application in Fig. 8.3 initializes an integer array with 10 values (line 10) and displays the array in tabular format. The code for displaying the array elements (lines 15–16) is identical to that in Fig. 8.2 (lines 17–18).

 1   // Fig. 8.3: InitArray.cs
 2   // Initializing the elements of an array with an array initializer.
 3   using System;
 4
 5   public class InitArray
 6   {
 7      public static void Main( string[] args )
 8      {
 9         // initializer list specifies the value for each element 
10         int[] array = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
11
12         Console.WriteLine( "{0}{1,8}", "Index", "Value" ); // headings
13
14         // output each array element's value
15         for ( int counter = 0; counter < array.Length; counter++ )
16            Console.WriteLine( "{0,5}{1,8}", counter, array[ counter ] );
17      } // end Main
18   } // end class InitArray

Index   Value
    0      32
    1      27
    2      64
    3      18
    4      95
    5      14
    6      90
    7      70
    8      60
    9      37

Some applications calculate the value to be stored in each array element. The application in Fig. 8.4 creates a 10-element array and assigns to each element one of the even integers from 2 to 20 (2, 4, 6, ..., 20). Then the application displays the array in tabular format. The for statement at lines 13–14 calculates an array element’s value by multiplying the current value of the for loop’s control variable counter by 2, then adding 2.

 1   // Fig. 8.4: InitArray.cs
 2   // Calculating values to be placed into the elements of an array.
 3   using System;
 4
 5   public class InitArray
 6   {
 7      public static void Main( string[] args )
 8      {
 9         const int ARRAY_LENGTH = 10; // create a named constant
10         int[] array = new int[ ARRAY_LENGTH ]; // create array 
11
12         // calculate value for each array element
13         for ( int counter = 0; counter < array.Length; counter++ )
14            array[ counter ] = 2 + 2 * counter;
15
16         Console.WriteLine( "{0}{1,8}", "Index", "Value" ); // headings
17
18         // output each array element's value
19         for ( int counter = 0; counter < array.Length; counter++ )
20            Console.WriteLine( "{0,5}{1,8}", counter, array[ counter ] );
21      } // end Main
22   } // end class InitArray

Index   Value
    0       2
    1       4
    2       6
    3       8
    4      10
    5      12
    6      14
    7      16
    8      18
    9      20

Line 9 uses the modifier const to declare the constant ARRAY_LENGTH, whose value is 10. Constants must be initialized when they’re declared and cannot be modified thereafter. We declare constants with all capital letters by convention to make them stand out in the code.

Common Programming Error 8.2

Assigning a value to a named constant after it’s been initialized is a compilation error.

Common Programming Error 8.3

Attempting to declare a named constant without initializing it is a compilation error.

Good Programming Practice 8.1

Constants also are called named constants. Applications using constants often are more readable than those that use literal values (e.g., 10)—a named constant such as ARRAY_LENGTH clearly indicates its purpose, whereas a literal value could have different meanings based on the context in which it’s used. Another advantage to using named constants is that if the value of the constant must be changed, the change is necessary only in the declaration, thus reducing the cost of maintaining the code.

Good Programming Practice 8.2

Defining the size of an array as a constant variable instead of a literal constant makes programs clearer. This technique eliminates so-called magic numbers. For example, repeatedly mentioning the size 10 in array-processing code for a 10-element array gives the number 10 an artificial significance and can be confusing when the program includes other 10s that have nothing to do with the array size.

Often, the elements of an array represent a series of values to be used in a calculation. For example, if the elements of an array represent exam grades, an instructor may wish to total the elements and use that total to calculate the class average for the exam. The GradeBook examples later in the chapter (Fig. 8.15 and Fig. 8.20) use this technique.

The application in Fig. 8.5 sums the values contained in a 10-element integer array. The application creates and initializes the array at line 9. The for statement performs the calculations. [Note: The values supplied as array initializers are often read into an application, rather than specified in an initializer list. For example, an application could input the values from a user or from a file on disk (as discussed in Chapter 17, Files and Streams). Reading the data into an application makes the application more reusable, because it can be used with different sets of data.]

 1   // Fig. 8.5: SumArray.cs
 2   // Computing the sum of the elements of an array.
 3   using System;
 4
 5   public class SumArray
 6   {
 7      public static void Main( string[] args )
 8      {
 9         int[] array = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
10         int total = 0;
11
12         // add each element's value to total                      
13         for ( int counter = 0; counter < array.Length; counter++ )
14            total += array[ counter ];                             
15
16         Console.WriteLine( "Total of array elements: {0}", total );
17      } // end Main
18   } // end class SumArray

Total of array elements: 849

Many applications present data to users in a graphical manner. For example, numeric values are often displayed as bars in a bar chart. In such a chart, longer bars represent proportionally larger numeric values. One simple way to display numeric data graphically is with a bar chart that shows each numeric value as a bar of asterisks (*).

An instructor might graph the number of grades in each of several categories to visualize the grade distribution for an exam. Suppose the grades on an exam were 87, 68, 94, 100, 83, 78, 85, 91, 76 and 87. There was one grade of 100, two grades in the 90s, four grades in the 80s, two grades in the 70s, one grade in the 60s and no grades below 60. Our next application (Fig. 8.6) stores this grade distribution data in an array of 11 elements, each corresponding to a category of grades. For example, array[0] indicates the number of grades in the range 0–9, array[7] the number of grades in the range 70–79 and array[10] the number of 100 grades. The two versions of class GradeBook later in the chapter (Figs. 8.15 and 8.20) contain code that calculates these grade frequencies based on a set of grades. For now, we manually create array by examining the set of grades and initializing the elements of array to the number of values in each range (line 9).

 1   // Fig. 8.6: BarChart.cs
 2   // Bar chart displaying application.
 3   using System;
 4
 5   public class BarChart
 6   {
 7      public static void Main( string[] args )
 8      {
 9         int[] array = { 0, 0, 0, 0, 0, 0, 1, 2, 4, 2, 1 }; // distribution
10
11         Console.WriteLine( "Grade distribution:" );
12
13         // for each array element, output a bar of the chart
14         for ( int counter = 0; counter < array.Length; counter++ )
15         {
16            // output bar labels ( "00-09: ", ..., "90-99: ", "100: " )
17            if ( counter == 10 )
18               Console.Write( " 100: " );
19            else
20               Console.Write( "{0:D2}-{1:D2}: ",
21                  counter * 10, counter * 10 + 9 );
22
23            // display bar of asterisks                             
24            for ( int stars = 0; stars < array[ counter ]; stars++ )
25               Console.Write( "*" );                                
26
27            Console.WriteLine(); // start a new line of output
28         } // end outer for
29      } // end Main
30   } // end class BarChart

Grade distribution:
00-09:
10-19:
20-29:
30-39:
40-49:
50-59:
60-69: *
70-79: **
80-89: ****
90-99: **
  100: *

The application reads the numbers from the array and graphs the information as a bar chart. Each grade range is followed by a bar of asterisks indicating the number of grades in that range. To label each bar, lines 17–21 output a grade range (e.g., "70-79: ") based on the current value of counter. When counter is 10, line 18 outputs " 100: " to align the colon with the other bar labels. When counter is not 10, line 20 uses the format items {0:D2} and {1:D2} to output the label of the grade range. The format specifier D indicates that the value should be formatted as an integer, and the number after the D indicates how many digits this formatted integer must contain. The 2 indicates that values with fewer than two digits should begin with a leading 0.

The nested for statement (lines 24–25) outputs the bars. Note the loop-continuation condition at line 24 (stars < array[ counter ]). Each time the application reaches the inner for, the loop counts from 0 up to one less than array[ counter ], thus using a value in array to determine the number of asterisks to display. In this example, array[0]–array[5] contain 0s because no students received a grade below 60. Thus, the application displays no asterisks next to the first six grade ranges.

Sometimes, applications use counter variables to summarize data, such as the results of a survey. In Fig. 7.7, we used separate counters in our die-rolling application to track the number of times each face of a six-sided die appeared as the application rolled the die 6000 times. An array version of the application in Fig. 7.7 is shown in Fig. 8.7.

 1   // Fig. 8.7: RollDie.cs
 2   // Roll a six-sided die 6000 times.
 3   using System;
 4
 5   public class RollDie
 6   {
 7      public static void Main( string[] args )
 8      {
 9         Random randomNumbers = new Random(); // random-number generator
10         int[] frequency = new int[ 7 ]; // array of frequency counters
11
12         // roll die 6000 times; use die value as frequency index
13         for ( int roll = 1; roll <= 6000; roll++ )
14            ++frequency[ randomNumbers.Next( 1, 7 ) ];
15
16         Console.WriteLine( "{0}{1,10}", "Face", "Frequency" );
17
18         // output each array element's value
19         for ( int face = 1; face < frequency.Length; face++ )
20            Console.WriteLine( "{0,4}{1,10}", face, frequency[ face ] );
21      } // end Main
22   } // end class RollDie

Face Frequency
   1       956
   2       981
   3      1001
   4      1030
   5      1035
   6       997

Figure 8.7 uses array frequency (line 10) to count the occurrences of each side of the die. The single statement in line 14 of this application replaces lines 26–46 of Fig. 7.7. Line 14 uses the random value to determine which frequency element to increment during each iteration of the loop. The calculation in line 14 produces random numbers from 1 to 6, so array frequency must be large enough to store six counters. We use a seven-element array in which we ignore frequency[0]—it’s more logical to have the face value 1 increment frequency[1] than frequency[0]. Thus, each face value is used as an index for array frequency. We also replaced lines 50–52 of Fig. 7.7 by looping through array frequency to output the results (Fig. 8.7, lines 19–20).

Our next example uses arrays to summarize data collected in a survey. Consider the following problem statement:

This is a typical array-processing application (Fig. 8.8). We wish to summarize the number of responses of each type (that is, 1–5). Array responses (lines 10–11) is a 20-element integer array containing the students’ survey responses. The last value in the array is intentionally an incorrect response (14). When a C# program executes, array element indices are checked for validity—all indices must be greater than or equal to 0 and less than the length of the array. Any attempt to access an element outside that range of indices results in a runtime error that is known as an IndexOutOfRangeException. At the end of this section, we’ll discuss the invalid response value, demonstrate array bounds checking and introduce C#’s exception-handling mechanism, which can be used to detect and handle an IndexOutOfRangeException.

 1   // Fig. 8.8: StudentPoll.cs
 2   // Poll analysis application.
 3   using System;
 4
 5   public class StudentPoll
 6   {
 7      public static void Main( string[] args )
 8      {
 9         // student response array (more typically, input at run time)
10         int[] responses = { 1, 2, 5, 4, 3, 5, 2, 1, 3, 3, 1, 4, 3, 3, 3,
11            2, 3, 3, 2, 14 };
12         int[] frequency = new int[ 6 ]; // array of frequency counters
13
14         // for each answer, select responses element and use that value
15         // as frequency index to determine element to increment        
16         for ( int answer = 0; answer < responses.Length; answer++ )    
17         {                                                              
18            try                                                         
19            {                                                           
20               ++frequency[ responses[ answer ] ];                      
21            } // end try                                                
22            catch ( IndexOutOfRangeException ex )                       
23            {                                                           
24               Console.WriteLine( ex.Message );                         
25               Console.WriteLine( "   responses({0}) = {1}
",          
26                  answer, responses[ answer ] );                        
27            } // end catch                                              
28         } // end for                                                   
29
30         Console.WriteLine( "{0}{1,10}", "Rating", "Frequency" );
31
32         // output each array element's value
33         for ( int rating = 1; rating < frequency.Length; rating++ )
34            Console.WriteLine( "{0,6}{1,10}", rating, frequency[ rating ] );
35      } // end Main
36   } // end class StudentPoll

Index was outside the bounds of the array.
   responses(19) = 14

Rating Frequency
     1         3
     2         4
     3         8
     4         2
     5         2

We use the six-element array frequency (line 12) to count the number of occurrences of each response. Each element is used as a counter for one of the possible types of survey responses—frequency[1] counts the number of students who rated the food as 1, frequency[2] counts the number of students who rated the food as 2, and so on.

The for statement (lines 16–28) reads the responses from the array responses one at a time and increments one of the counters frequency[1] to frequency[5]; we ignore frequency[0] because the survey responses are limited to the range 1–5. The key statement in the loop appears in line 20. This statement increments the appropriate frequency counter as determined by the value of responses[answer].

Let’s step through the first few iterations of the for statement:

Regardless of the number of responses processed in the survey, only a six-element array (in which we ignore element zero) is required to summarize the results, because all the correct response values are between 1 and 5, and the index values for a six-element array are 0–5. In the output in Fig. 8.8, the frequency column summarizes only 19 of the 20 values in the responses array—the last element of the array responses contains an incorrect response that was not counted.

An exception indicates a problem that occurs while a program executes. The name “exception” suggests that the problem occurs infrequently—if the “rule” is that a statement normally executes correctly, then the problem represents the “exception to the rule.” Exception handling enables you to create fault-tolerant programs that can resolve (or handle) exceptions. In many cases, this allows a program to continue executing as if no problems were encountered. For example, the Student Poll application still displays results (Fig. 8.8), even though one of the responses was out of range. More severe problems might prevent a program from continuing normal execution, instead requiring the program to notify the user of the problem, then terminate. When the runtime or a method detects a problem, such as an invalid array index or an invalid method argument, it throws an exception—that is, an exception occurs.

To handle an exception, place any code that might throw an exception in a try statement (lines 18–27). The try block (lines 18–21) contains the code that might throw an exception, and the catch block (lines 22–27) contains the code that handles the exception if one occurs. You can have many catch blocks to handle different types of exceptions that might be thrown in the corresponding try block. When line 20 correctly increments an element of the frequency array, lines 22–27 are ignored. The braces that delimit the bodies of the try and catch blocks are required.

When the program encounters the value 14 in the responses array, it attempts to add 1 to frequency[14], which does not exist—the frequency array has only six elements. Because array bounds checking is performed at execution time, the Common Language Runtime generates an exception—specifically line 20 throws an IndexOutOfRangeException to notify the program of this problem. At this point the try block terminates and the catch block begins executing—if you declared any variables in the try block, they’re now out of scope and are not accessible in the catch block.

The catch block declares a type (IndexOutOfRangeException) and an exception parameter (ex). The catch block can handle exceptions of the specified type. Inside the catch block, you can use the parameter’s identifier to interact with a caught exception object.

Error-Prevention Tip 8.1

When writing code to access an array element, ensure that the array index remains greater than or equal to 0 and less than the length of the array. This helps prevent IndexOutOfRangeExceptions in your program.

When lines 22–27 catch the exception, the program displays a message indicating the problem that occurred. Line 24 uses the exception object’s Message property to get the error message that is stored in the exception object and display it. Once the message is displayed in this example, the exception is considered handled and the program continues with the next statement after the catch block’s closing brace. In this example, the end of the for statement is reached (line 28), so the program continues with the increment of the control variable in line 16. We use exception handling again in Chapter 10 and Chapter 13 presents a deeper look at exception handling.

Class Card (Fig. 8.9) contains two string instance variables—face and suit—that are used to store references to the face value and suit name for a specific Card. The constructor for the class (lines 9–13) receives two strings that it uses to initialize face and suit. Method ToString (lines 16–19) creates a string consisting of the face of the card, the string " of " and the suit of the card. Recall from Chapter 7 that the + operator can be used to concatenate (i.e., combine) several strings to form one larger string. Card’s ToString method can be invoked explicitly to obtain a string representation of a Card object (e.g., "Ace of Spades"). The ToString method of an object is called implicitly in many cases when the object is used where a string is expected (e.g., when WriteLine outputs the object or when the object is concatenated to a string using the + operator). For this behavior to occur, ToString must be declared with the header exactly as shown in line 16 of Fig. 8.9. We’ll explain the purpose of the override keyword in more detail when we discuss inheritance in Chapter 11.

Class DeckOfCards (Fig. 8.10) declares an instance-variable named deck that will refer to an array of Card objects (line 7). Like simple-type array variable declarations, the declaration of a variable for an array of objects (e.g., Card[] deck) includes the type of the elements in the array, followed by square brackets and the name of the array variable. Class DeckOfCards also declares int instance variable currentCard (line 8), representing the next Card to be dealt from the deck array, and named constant NUMBER_OF_CARDS (line 9), indicating the number of Cards in the deck (52).

The class’s constructor instantiates the deck array (line 19) to be of size NUMBER_OF_CARDS. When first created, the elements of the deck array are null by default, so the constructor uses a for statement (lines 24–26) to fill the deck array with Cards. The for statement initializes control variable count to 0 and loops while count is less than deck.Length, causing count to take on each integer value from 0 to 51 (the indices of the deck array). Each Card is instantiated and initialized with two strings—one from the faces array (which contains the strings "Ace" through "King") and one from the suits array (which contains the strings "Hearts", "Diamonds", "Clubs" and "Spades"). The calculation count % 13 always results in a value from 0 to 12 (the 13 indices of the faces array in lines 15–16), and the calculation count / 13 always results in a value from 0 to 3 (the four indices of the suits array in line 17). When the deck array is initialized, it contains the Cards with faces "Ace" through "King" in order for each suit.

 1   // Fig. 8.10: DeckOfCards.cs
 2   // DeckOfCards class represents a deck of playing cards.
 3   using System;
 4
 5   public class DeckOfCards
 6   {
 7      private Card[] deck; // array of Card objects
 8      private int currentCard; // index of next Card to be dealt (0-51)
 9      private const int NUMBER_OF_CARDS = 52; // constant number of Cards
10      private Random randomNumbers; // random-number generator
11
12      // constructor fills deck of Cards
13      public DeckOfCards()
14      {
15         string[] faces = { "Ace", "Deuce", "Three", "Four", "Five", "Six",
16            "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King" };    
17         string[] suits = { "Hearts", "Diamonds", "Clubs", "Spades" };     
18
19         deck = new Card[ NUMBER_OF_CARDS ]; // create array of Card objects
20         currentCard = 0; // set currentCard so deck[ 0 ] is dealt first
21         randomNumbers = new Random(); // create random-number generator
22
23         // populate deck with Card objects                         
24         for ( int count = 0; count < deck.Length; count++ )        
25            deck[ count ] =                                         
26               new Card( faces[ count % 13 ], suits[ count / 13 ] );
27      } // end DeckOfCards constructor
28
29      // shuffle deck of Cards with one-pass algorithm
30      public void Shuffle()
31      {
32         // after shuffling, dealing should start at deck[ 0 ] again
33         currentCard = 0; // reinitialize currentCard
34
35         // for each Card, pick another random Card and swap them
36         for ( int first = 0; first < deck.Length; first++ )
37         {
38            // select a random number between 0 and 51
39            int second = randomNumbers.Next( NUMBER_OF_CARDS );
40
41            // swap current Card with randomly selected Card
42            Card temp = deck[ first ];     
43            deck[ first ] = deck[ second ];
44            deck[ second ] = temp;         
45         } // end for
46      } // end method Shuffle
47
48      // deal one Card
49      public Card DealCard()
50      {
51         // determine whether Cards remain to be dealt
52         if ( currentCard < deck.Length )
53            return deck[ currentCard++ ]; // return current Card in array
54         else
55            return null; // indicate that all Cards were dealt
56      } // end method DealCard
57   } // end class DeckOfCards

Method Shuffle (lines 30–46) shuffles the Cards in the deck. The method loops through all 52 Cards (array indices 0 to 51). For each Card, a number between 0 and 51 is picked randomly to select another Card. Next, the current Card object and the randomly selected Card object are swapped in the array. This exchange is performed by the three assignments in lines 42–44. The extra variable temp temporarily stores one of the two Card objects being swapped. The swap cannot be performed with only the two statements

deck[ first ] = deck[ second ];
deck[ second ] = deck[ first ];

If deck[ first ] is the "Ace" of "Spades" and deck[ second ] is the "Queen" of "Hearts", then after the first assignment, both array elements contain the "Queen" of "Hearts", and the "Ace" of "Spades" is lost—hence, the extra variable temp is needed. After the for loop terminates, the Card objects are randomly ordered. Only 52 swaps are made in a single pass of the entire array, and the array of Card objects is shuffled. [Note: It’s recommended that you use a so-called unbiased shuffling algorithm for real card games. Such an algorithm ensures that all possible shuffled card sequences are equally likely to occur. A popular unbiased shuffling algorithm is the Fisher-Yates algorithm—en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle. This page also shows how to implement the algorithm in several programming languages.]

Method DealCard (lines 49–56) deals one Card in the array. Recall that currentCard indicates the index of the next Card to be dealt (i.e., the Card at the top of the deck). Thus, line 52 compares currentCard to the length of the deck array. If the deck is not empty (i.e., currentCard is less than 52), line 53 returns the top Card and increments currentCard to prepare for the next call to DealCard—otherwise, null is returned.

The application of Fig. 8.11 demonstrates the card shuffling and dealing capabilities of class DeckOfCards (Fig. 8.10). Line 10 creates a DeckOfCards object named myDeckOfCards. Recall that the DeckOfCards constructor creates the deck with the 52 Card objects in order by suit and face. Line 11 invokes myDeckOfCards’s Shuffle method to rearrange the Card objects. The for statement in lines 14–20 deals all 52 Cards in the deck and displays them in four columns of 13 Cards each. Line 16 deals and displays a Card object by invoking myDeckOfCards’s DealCard method. When Console.Write outputs a Card with string formatting, the Card’s ToString method (declared in lines 16–19 of Fig. 8.9) is invoked implicitly. Because the field width is negative, the result is output left justified in a field of width 19.

 1   // Fig. 8.11: DeckOfCardsTest.cs
 2   // Card shuffling and dealing application.
 3   using System;
 4
 5   public class DeckOfCardsTest
 6   {
 7      // execute application
 8      public static void Main( string[] args )
 9      {
10         DeckOfCards myDeckOfCards = new DeckOfCards();
11         myDeckOfCards.Shuffle(); // place Cards in random order
12
13         // display all 52 Cards in the order in which they are dealt
14         for ( int i = 0; i < 52; i++ )
15         {
16            Console.Write( "{0,-19}", myDeckOfCards.DealCard() );
17
18            if ( ( i + 1 ) % 4 == 0 )
19               Console.WriteLine();
20         } // end for
21      } // end Main
22   } // end class DeckOfCardsTest

Eight of Clubs     Ten of Clubs       Ten of Spades      Four of Spades
Ace of Spades      Jack of Spades     Three of Spades    Seven of Spades
Three of Diamonds  Five of Clubs      Eight of Spades    Five of Hearts
Ace of Hearts      Ten of Hearts      Deuce of Hearts    Deuce of Clubs
Jack of Hearts     Nine of Spades     Four of Hearts     Seven of Clubs
Queen of Spades    Seven of Diamonds  Five of Diamonds   Ace of Clubs
Four of Clubs      Ten of Diamonds    Jack of Clubs      Six of Diamonds
Eight of Diamonds  King of Hearts     Three of Clubs     King of Spades
King of Diamonds   Six of Spades      Deuce of Spades    Five of Spades
Queen of Clubs     King of Clubs      Queen of Hearts    Seven of Hearts
Ace of Diamonds    Deuce of Diamonds  Four of Diamonds   Nine of Clubs
Queen of Diamonds  Jack of Diamonds   Six of Hearts      Nine of Diamonds
Nine of Hearts     Three of Hearts    Six of Clubs       Eight of Hearts

The version of class GradeBook (Fig. 8.15) presented here uses an array of integers to store the grades of several students on a single exam. This eliminates the need to repeatedly input the same set of grades. Variable grades (which will refer to an array of ints) is declared as an instance variable in line 7—therefore, each GradeBook object maintains its own set of grades. The class’s constructor (lines 14–18) has two parameters—the name of the course and an array of grades. When an application (e.g., class GradeBookTest in Fig. 8.16) creates a GradeBook object, the application passes an existing int array to the constructor, which assigns the array’s reference to instance variable grades (line 17). The size of array grades is determined by the class that passes the array to the constructor.

 1   // Fig. 8.15: GradeBook.cs
 2   // Grade book using an array to store test grades.
 3   using System;
 4
 5   public class GradeBook
 6   {
 7      private int[] grades; // array of student grades
 8
 9      // auto-implemented property CourseName
10      public string CourseName { get; set; }
11
12      // two-parameter constructor initializes
13      // auto-implemented property CourseName and grades array
14      public GradeBook( string name, int[] gradesArray )
15      {
16         CourseName = name; // set CourseName to name
17         grades = gradesArray; // initialize grades array
18      } // end two-parameter GradeBook constructor
19
20      // display a welcome message to the GradeBook user
21      public void DisplayMessage()
22      {
23         // auto-implemented property CourseName gets the name of course
24         Console.WriteLine( "Welcome to the grade book for
{0}!
",
25            CourseName );
26      } // end method DisplayMessage
27
28      // perform various operations on the data
29      public void ProcessGrades()
30      {
31         // output grades array
32         OutputGrades();
33
34         // call method GetAverage to calculate the average grade
35         Console.WriteLine( "
Class average is {0:F}", GetAverage() );
36
37         // call methods GetMinimum and GetMaximum
38         Console.WriteLine( "Lowest grade is {0}
Highest grade is {1}
",
39            GetMinimum(), GetMaximum() );
40
41         // call OutputBarChart to display grade distribution chart
42         OutputBarChart();
43      } // end method ProcessGrades
44
45      // find minimum grade
46      public int GetMinimum()
47      {
48         int lowGrade = grades[ 0 ]; // assume grades[ 0 ] is smallest
49
50         // loop through grades array                             
51         foreach ( int grade in grades )                          
52         {                                                        
53            // if grade lower than lowGrade, assign it to lowGrade
54            if ( grade < lowGrade )                               
55               lowGrade = grade; // new lowest grade              
56         } // end for                                             
57
58         return lowGrade; // return lowest grade
59      } // end method GetMinimum
60
61      // find maximum grade
62      public int GetMaximum()
63      {
64         int highGrade = grades[ 0 ]; // assume grades[ 0 ] is largest
65
66         // loop through grades array
67         foreach ( int grade in grades )
68         {
69            // if grade greater than highGrade, assign it to highGrade
70            if ( grade > highGrade )
71               highGrade = grade; // new highest grade
72         } // end for
73
74         return highGrade; // return highest grade
75      } // end method GetMaximum
76
77      // determine average grade for test
78      public double GetAverage()
79      {
80         int total = 0; // initialize total
81
82         // sum grades for one student  
83         foreach ( int grade in grades )
84            total += grade;             
85
86         // return average of grades
87         return ( double ) total / grades.Length;
88      } // end method GetAverage
89
90      // output bar chart displaying grade distribution
91      public void OutputBarChart()
92      {
93         Console.WriteLine( "Grade distribution:" );
94
95         // stores frequency of grades in each range of 10 grades
96         int[] frequency = new int[ 11 ];
97
98         // for each grade, increment the appropriate frequency
99         foreach ( int grade in grades )                       
100           ++frequency[ grade / 10 ];                         
101
102        // for each grade frequency, display bar in chart
103        for ( int count = 0; count < frequency.Length; count++ )
104        {
105           // output bar label ( "00-09: ", ..., "90-99: ", "100: " )
106           if ( count == 10 )
107              Console.Write( " 100: " );
108           else
109              Console.Write( "{0:D2}-{1:D2}: ",
110                 count * 10, count * 10 + 9 );
111
112           // display bar of asterisks
113           for ( int stars = 0; stars < frequency[ count ]; stars++ )
114              Console.Write( "*" );
115
116           Console.WriteLine(); // start a new line of output
117        } // end outer for
118     } // end method OutputBarChart
119
120     // output the contents of the grades array
121     public void OutputGrades()
122     {
123        Console.WriteLine( "The grades are:
" );
124
125        // output each student's grade                             
126        for ( int student = 0; student < grades.Length; student++ )
127           Console.WriteLine( "Student {0,2}: {1,3}",              
128              student + 1, grades[ student ] );                    
129     } // end method OutputGrades
130  } // end class GradeBook

Thus, a GradeBook object can process a variable number of grades—as many as are in the array in the caller. The grade values in the passed array could have been input from a user at the keyboard or read from a file on disk (as discussed in Chapter 17). In our test application, we simply initialize an array with a set of grade values (Fig. 8.16, line 9). Once the grades are stored in instance variable grades of class GradeBook, all the class’s methods can access the elements of grades as needed to perform various calculations.

 1   // Fig. 8.16: GradeBookTest.cs
 2   // Create GradeBook object using an array of grades.
 3   public class GradeBookTest
 4   {
 5      // Main method begins application execution
 6      public static void Main( string[] args )
 7      {
 8         // one-dimensional array of student grades                      
 9         int[] gradesArray = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
10
11         GradeBook myGradeBook = new GradeBook(
12            "CS101 Introduction to C# Programming", gradesArray );
13         myGradeBook.DisplayMessage();
14         myGradeBook.ProcessGrades();
15      } // end Main
16   } // end class GradeBookTest

Welcome to the grade book for
CS101 Introduction to C# Programming!

The grades are:

Student  1:  87
Student  2:  68
Student  3:  94
Student  4: 100
Student  5:  83
Student  6:  78
Student  7:  85
Student  8:  91
Student  9:  76
Student 10:  87

Class average is 84.90
Lowest grade is 68
Highest grade is 100

Grade distribution:
00-09:
10-19:
20-29:
30-39:
40-49:
50-59:
60-69: *
70-79: **
80-89: ****
90-99: **
  100: *

Method ProcessGrades (lines 29–43) contains a series of method calls that result in the output of a report summarizing the grades. Line 32 calls method OutputGrades to display the contents of array grades. Lines 126–128 in method OutputGrades use a for statement to output the student grades. A for statement, rather than a foreach, must be used in this case, because lines 127–128 use counter variable student’s value to output each grade next to a particular student number (see Fig. 8.16). Although array indices start at 0, an instructor would typically number students starting at 1. Thus, lines 127–128 output student + 1 as the student number to produce grade labels "Student 1: ", "Student 2: " and so on.

Method ProcessGrades next calls method GetAverage (line 35) to obtain the average of the grades in the array. Method GetAverage (lines 78–88) uses a foreach statement to total the values in array grades before calculating the average. The iteration variable in the foreach’s header (e.g., int grade) indicates that for each iteration, int variable grade takes on a value in array grades. The averaging calculation in line 87 uses grades.Length to determine the number of grades being averaged.

Lines 38–39 in method ProcessGrades call methods GetMinimum and GetMaximum to determine the lowest and highest grades of any student on the exam, respectively. Each of these methods uses a foreach statement to loop through array grades. Lines 51–56 in method GetMinimum loop through the array, and lines 54–55 compare each grade to lowGrade. If a grade is less than lowGrade, lowGrade is set to that grade. When line 58 executes, lowGrade contains the lowest grade in the array. Method GetMaximum (lines 62–75) works the same way as method GetMinimum.

Finally, line 42 in method ProcessGrades calls method OutputBarChart to display a distribution chart of the grade data, using a technique similar to that in Fig. 8.6. In that example, we manually calculated the number of grades in each category (i.e., 0–9, 10–19, ..., 90–99 and 100) by simply looking at a set of grades. In this example, lines 99–100 use a technique similar to that in Figs. 8.7 and 8.8 to calculate the frequency of grades in each category. Line 96 declares variable frequency and initializes it with an array of 11 ints to store the frequency of grades in each grade category. For each grade in array grades, lines 99–100 increment the appropriate element of the frequency array. To determine which element to increment, line 100 divides the current grade by 10, using integer division. For example, if grade is 85, line 100 increments frequency[8] to update the count of grades in the range 80–89. Lines 103–117 next display the bar chart (see Fig. 8.6) based on the values in array frequency. Like lines 24–25 of Fig. 8.6, lines 113–114 of Fig. 8.15 use a value in array frequency to determine the number of asterisks to display in each bar.

The application of Fig. 8.16 creates an object of class GradeBook (Fig. 8.15) using int array gradesArray (declared and initialized in line 9). Lines 11–12 pass a course name and gradesArray to the GradeBook constructor. Line 13 displays a welcome message, and line 14 invokes the GradeBook object’s ProcessGrades method. The output reveals the summary of the 10 grades in myGradeBook.

Software Engineering Observation 8.3

A test harness (or test application) is responsible for creating an object of the class being tested and providing it with data. This data could come from any of several sources. Test data can be placed directly into an array with an array initializer, it can come from the user at the keyboard or it can come from a file (as you’ll see in Chapter 17). After passing this data to the class’s constructor to instantiate the object, the test harness should call the object to test its methods and manipulate its data. Gathering data in the test harness like this allows the class to manipulate data from several sources.

Rectangular arrays are used to represent tables of information in the form of rows and columns, where each row has the same number of columns. Figure 8.17 illustrates a rectangular array named a containing three rows and four columns—a three-by-four array. In general, an array with m rows and n columns is called an m-by-narray.

Every element in array a is identified in Fig. 8.17 by an array-access expression of the form a[row, column]; a is the name of the array, and row and column are the indices that uniquely identify each element in array a by row and column number. The names of the elements in row 0 all have a first index of 0, and the names of the elements in column 3 all have a second index of 3.

Figure 8.17. Rectangular array with three rows and four columns.

Like one-dimensional arrays, multidimensional arrays can be initialized with array initializers in declarations. A rectangular array b with two rows and two columns could be declared and initialized with nested array initializers as follows:

int[ , ] b = { { 1, 2 }, { 3, 4 } };

The initializer values are grouped by row in braces. So 1 and 2 initialize b[0, 0] and b[0, 1], respectively, and 3 and 4 initialize b[1, 0] and b[1, 1], respectively. The compiler counts the number of nested array initializers (represented by sets of two inner braces within the outer braces) in the initializer list to determine the number of rows in array b. The compiler counts the initializer values in the nested array initializer for a row to determine the number of columns (two) in that row. The compiler will generate an error if the number of initializers in each row is not the same, because every row of a rectangular array must have the same length.

A jagged array is maintained as a one-dimensional array in which each element refers to a one-dimensional array. The manner in which jagged arrays are represented makes them quite flexible, because the lengths of the rows in the array need not be the same. For example, jagged arrays could be used to store a single student’s exam grades across multiple classes, where the number of exams may vary from class to class.

We can access the elements in a jagged array by an array-access expression of the form arrayName[row][column]—similar to the array-access expression for rectangular arrays, but with a separate set of square brackets for each dimension. A jagged array with three rows of different lengths could be declared and initialized as follows:

int[][] jagged = { new int[] { 1, 2 },
                   new int[] { 3 },
                   new int[] { 4, 5, 6 } };

In this statement, 1 and 2 initialize jagged[0][0] and jagged[0][1], respectively; 3 initializes jagged[1][0]; and 4, 5 and 6 initialize jagged[2][0], jagged[2][1] and jagged[2][2], respectively. Therefore, array jagged in the preceding declaration is actually composed of four separate one-dimensional arrays—one that represents the rows, one containing the values in the first row ({1, 2}), one containing the value in the second row ({3}) and one containing the values in the third row ({4, 5, 6}). Thus, array jagged itself is an array of three elements, each a reference to a one-dimensional array of int values.

Observe the differences between the array-creation expressions for rectangular arrays and for jagged arrays. Two sets of square brackets follow the type of jagged, indicating that this is an array of int arrays. Furthermore, in the array initializer, C# requires the keyword new to create an array object for each row. Figure 8.18 illustrates the array reference jagged after it’s been declared and initialized.

Figure 8.18. Jagged array with three rows of different lengths.

A rectangular array can be created with an array-creation expression. For example, the following lines declare variable b and assign it a reference to a three-by-four rectangular array:

int[ , ] b;
b = new int[ 3, 4 ];

In this case, we use the literal values 3 and 4 to specify the number of rows and number of columns, respectively, but this is not required—applications can also use variables and expressions to specify array dimensions. As with one-dimensional arrays, the elements of a rectangular array are initialized when the array object is created.

A jagged array cannot be completely created with a single array-creation expression. The following statement is a syntax error:

int[][] c = new int[ 2 ][ 5 ]; // error

Instead, each one-dimensional array in the jagged array must be initialized separately. A jagged array can be created as follows:

int[][] c;
c = new int[ 2 ][ ]; // create 2 rows
c[ 0 ] = new int[ 5 ]; // create 5 columns for row 0
c[ 1 ] = new int[ 3 ]; // create 3 columns for row 1

The preceding statements create a jagged array with two rows. Row 0 has five columns, and row 1 has three columns.

Figure 8.19 demonstrates initializing rectangular and jagged arrays with array initializers and using nested for loops to traverse the arrays (i.e., visit every element of each array).

 1   // Fig. 8.19: InitArray.cs
 2   // Initializing rectangular and jagged arrays.
 3   using System;
 4
 5   public class InitArray
 6   {
 7      // create and output rectangular and jagged arrays
 8      public static void Main( string[] args )
 9      {
10         // with rectangular arrays,
11         // every row must be the same length.
12         int[ , ] rectangular = { { 1, 2, 3 }, { 4, 5, 6 } };
13
14         // with jagged arrays,
15         // we need to use "new int[]" for every row,
16         // but every row does not need to be the same length.
17         int[][] jagged = { new int[] { 1, 2 },     
18                            new int[] { 3 },        
19                            new int[] { 4, 5, 6 } };
20
21         OutputArray( rectangular ); // displays array rectangular by row
22         Console.WriteLine(); // output a blank line
23         OutputArray( jagged ); // displays array jagged by row
24      } // end Main
25
26      // output rows and columns of a rectangular array
27      public static void OutputArray( int[ , ] array )
28      {
29         Console.WriteLine( "Values in the rectangular array by row are" );
30
31         // loop through array's rows                                      
32         for ( int row = 0; row < array.GetLength( 0 ); row++ )            
33         {                                                                 
34            // loop through columns of current row                         
35            for ( int column = 0; column < array.GetLength( 1 ); column++ )
36               Console.Write( "{0}  ", array[ row, column ] );              
37                                                                           
38            Console.WriteLine(); // start new line of output               
39         } // end outer for                                                
40      } // end method OutputArray
41
42      // output rows and columns of a jagged array
43      public static void OutputArray( int[][] array )
44      {
45         Console.WriteLine( "Values in the jagged array by row are" );
46
47         // loop through each row                           
48         foreach ( int[] row in array )                     
49         {                                                  
50            // loop through each element in current row     
51            foreach ( int element in row )                  
52               Console.Write( "{0}  ", element );           
53                                                            
54            Console.WriteLine(); // start new line of output
55         } // end outer foreach                             
56      } // end method OutputArray
57   } // end class InitArray

Values in the rectangular array by row are
1  2  3
4  5  6

Values in the jagged array by row are
1  2
3
4  5  6

Class InitArray’s Main method creates two arrays. Line 12 uses nested array initializers to initialize variable rectangular with an array in which row 0 has the values 1, 2 and 3, and row 1 has the values 4, 5 and 6. Lines 17–19 uses nested initializers of different lengths to initialize variable jagged. In this case, the initializer uses the keyword new to create a one-dimensional array for each row. Row 0 is initialized to have two elements with values 1 and 2, respectively. Row 1 is initialized to have one element with value 3. Row 2 is initialized to have three elements with the values 4, 5 and 6, respectively.

Method OutputArray has been overloaded with two versions. The first version (lines 27–40) specifies the array parameter as int[,] array to indicate that it takes a rectangular array. The second version (lines 43–56) takes a jagged array, because its array parameter is listed as int[][] array.

Line 21 invokes method OutputArray with argument rectangular, so the version of OutputArray at lines 27–40 is called. The nested for statement (lines 32–39) outputs the rows of a rectangular array. The loop-continuation condition of each for statement (lines 32 and 35) uses the rectangular array’s GetLength method to obtain the length of each dimension. Dimensions are numbered starting from 0, so the method call GetLength(0) on array returns the size of the first dimension of the array (the number of rows), and the call GetLength(1) returns the size of the second dimension (the number of columns).

Line 23 invokes method OutputArray with argument jagged, so the version of OutputArray at lines 43–56 is called. The nested foreach statement (lines 48–55) outputs the rows of a jagged array. The inner foreach statement (lines 51–52) iterates through each element in the current row of the array. This allows the loop to determine the exact number of columns in each row. Since the jagged array is created as an array of arrays, we can use nested foreach statements to output the elements in the console window. The outer loop iterates through the elements of array, which are references to one-dimensional arrays of int values that represent each row. The inner loop iterates through the elements of the current row. A foreach statement can also iterate through all the elements in a rectangular array. In this case, foreach iterates through all the rows and columns starting from row 0, as if the elements were in a one-dimensional array.

Many common array manipulations use for statements. As an example, the following for statement sets all the elements in row 2 of rectangular array a in Fig. 8.17 to 0:

for ( int column = 0; column < a.GetLength( 1 ); column++)
   a[ 2, column ] = 0;

We specified row 2; therefore, we know that the first index is always 2 (0 is the first row, and 1 is the second row). This for loop varies only the second index (i.e., the column index). The preceding for statement is equivalent to the assignment statements

a[ 2, 0 ] = 0;
a[ 2, 1 ] = 0;
a[ 2, 2 ] = 0;
a[ 2, 3 ] = 0;

The following nested for statement totals the values of all the elements in array a:

int total = 0;

for ( int row = 0; row < a.GetLength( 0 ); row++ )
{
   for ( int column = 0; column < a.GetLength( 1 ); column++ )
      total += a[ row, column ];
} // end outer for

These nested for statements total the array elements one row at a time. The outer for statement begins by setting the row index to 0 so that row 0’s elements can be totaled by the inner for statement. The outer for then increments row to 1 so that row 1’s elements can be totaled. Then the outer for increments row to 2 so that row 2’s elements can be totaled. The variable total can be displayed when the outer for statement terminates. In the next example, we show how to process a rectangular array in a more concise manner using foreach statements.

Figure 8.20 contains a version of class GradeBook that uses a rectangular array grades to store the grades of a number of students on multiple exams. Each row of the array represents a single student’s grades for the entire course, and each column represents the grades for the whole class on one of the exams the students took during the course. An application such as GradeBookTest (Fig. 8.21) passes the array as an argument to the GradeBook constructor. In this example, we use a 10-by-3 array containing 10 students’ grades on three exams. Five methods perform array manipulations to process the grades. Each method is similar to its counterpart in the earlier one-dimensional-array version of class GradeBook (Fig. 8.15). Method GetMinimum (lines 44–58) determines the lowest grade of any student for the semester. Method GetMaximum (lines 61–75) determines the highest grade of any student for the semester. Method GetAverage (lines 78–90) determines a particular student’s semester average. Method OutputBarChart (lines 93–122) outputs a bar chart of the distribution of all student grades for the semester. Method OutputGrades (lines 125–149) outputs the two-dimensional array in tabular format, along with each student’s semester average.

 1   // Fig. 8.20: GradeBook.cs
 2   // Grade book using rectangular array to store grades.
 3   using System;
 4
 5   public class GradeBook
 6   {
 7      private int[ , ] grades; // rectangular array of student grades
 8
 9      // auto-implemented property CourseName
10      public string CourseName { get; set; }
11
12      // two-parameter constructor initializes
13      // auto-implemented property CourseName and grades array
14      public GradeBook( string name, int[ , ] gradesArray )
15      {
16         CourseName = name; // set CourseName to name
17         grades = gradesArray; // initialize grades array
18      } // end two-parameter GradeBook constructor
19
20      // display a welcome message to the GradeBook user
21      public void DisplayMessage()
22      {
23         // auto-implemented property CourseName gets the name of course
24         Console.WriteLine( "Welcome to the grade book for
{0}!
",
25            CourseName );
26      } // end method DisplayMessage
27
28      // perform various operations on the data
29      public void ProcessGrades()
30      {
31         // output grades array
32         OutputGrades();
33
34         // call methods GetMinimum and GetMaximum
35         Console.WriteLine( "
{0} {1}
{2} {3}
",
36            "Lowest grade in the grade book is", GetMinimum(),
37            "Highest grade in the grade book is", GetMaximum() );
38
39         // output grade distribution chart of all grades on all tests
40         OutputBarChart();
41      } // end method ProcessGrades
42
43      // find minimum grade
44      public int GetMinimum()
45      {
46         // assume first element of grades array is smallest
47         int lowGrade = grades[ 0, 0 ];
48
49         // loop through elements of rectangular grades array    
50         foreach ( int grade in grades )                         
51         {                                                       
52            // if grade less than lowGrade, assign it to lowGrade
53            if ( grade < lowGrade )                              
54               lowGrade = grade;                                 
55         } // end foreach                                        
56
57         return lowGrade; // return lowest grade
58      } // end method GetMinimum
59
60      // find maximum grade
61      public int GetMaximum()
62      {
63         // assume first element of grades array is largest
64         int highGrade = grades[ 0, 0 ];
65
66         // loop through elements of rectangular grades array
67         foreach ( int grade in grades )
68         {
69            // if grade greater than highGrade, assign it to highGrade
70            if ( grade > highGrade )
71               highGrade = grade;
72         } // end foreach
73
74         return highGrade; // return highest grade
75      } // end method GetMaximum
76
77      // determine average grade for particular student
78      public double GetAverage( int student )          
79      {                                                
80         // get the number of grades per student       
81         int amount = grades.GetLength( 1 );           
82         int total = 0; // initialize total            
83                                                       
84         // sum grades for one student                 
85         for ( int exam = 0; exam < amount; exam++ )   
86            total += grades[ student, exam ];          
87                                                       
88         // return average of grades                   
89         return ( double ) total / amount;             
90      } // end method GetAverage                       
91
92      // output bar chart displaying overall grade distribution
93      public void OutputBarChart()
94      {
95         Console.WriteLine( "Overall grade distribution:" );
96
97         // stores frequency of grades in each range of 10 grades
98         int[] frequency = new int[ 11 ];
99
100        // for each grade in GradeBook, increment the appropriate frequency
101        foreach ( int grade in grades )                                    
102        {                                                                  
103           ++frequency[ grade / 10 ];                                      
104        } // end foreach                                                   
105
106        // for each grade frequency, display bar in chart
107        for ( int count = 0; count < frequency.Length; count++ )
108        {
109           // output bar label ( "00-09: ", ..., "90-99: ", "100: " )
110           if ( count == 10 )
111              Console.Write( " 100: " );
112           else
113              Console.Write( "{0:D2}-{1:D2}: ",
114                 count * 10, count * 10 + 9 );
115
116           // display bar of asterisks
117           for ( int stars = 0; stars < frequency[ count ]; stars++ )
118              Console.Write( "*" );
119
120           Console.WriteLine(); // start a new line of output
121        } // end outer for
122     } // end method OutputBarChart
123
124     // output the contents of the grades array
125     public void OutputGrades()
126     {
127        Console.WriteLine( "The grades are:
" );
128        Console.Write( "            " ); // align column heads
129
130     // create a column heading for each of the tests
131     for ( int test = 0; test < grades.GetLength( 1 ); test++ )
132        Console.Write( "Test {0}  ", test + 1 );
133
134     Console.WriteLine( "Average" ); // student average column heading
135
136     // create rows/columns of text representing array grades
137     for ( int student = 0; student < grades.GetLength( 0 ); student++ )
138     {
139        Console.Write( "Student {0,2}", student + 1 );
140
141        // output student's grades
142        for ( int grade = 0; grade < grades.GetLength( 1 ); grade++ )
143           Console.Write( "{0,8}", grades[ student, grade ] );
144
145           // call method GetAverage to calculate student's average grade;
146           // pass row number as the argument to GetAverage
147           Console.WriteLine( "{0,9:F}", GetAverage( student ) );
148        } // end outer for
149     } // end method OutputGrades
150  } // end class GradeBook