Most computer applications that solve real-world problems are much larger than the applications presented in this book’s first few chapters. Experience has shown that the best way to develop and maintain a large application is to construct it from small, simple pieces. This technique is called divide and conquer. We introduced methods in Chapter 4. In this chapter we study methods in more depth. We emphasize how to declare and use methods to facilitate the design, implementation, operation and maintenance of large applications.

You’ll see that it’s possible for certain methods, called static methods, to be called without the need for an object of the class to exist. You’ll learn how to declare a method with more than one parameter. You’ll also learn how C# is able to keep track of which method is currently executing, how value-type and reference-type arguments are passed to methods, how local variables of methods are maintained in memory and how a method knows where to return after it completes execution.

We discuss simulation techniques with random-number generation and develop a version of the casino dice game called craps that uses most of the programming techniques you’ve learned to this point in the book. In addition, you’ll learn to declare values that cannot change (i.e., constants). You’ll also learn to write methods that call themselves—this is called recursion.

Many of the classes you’ll use or create while developing applications will have more than one method of the same name. This technique, called method overloading, is used to implement methods that perform similar tasks but with different types and/or different numbers of arguments.

Common ways of packaging code are properties, methods, classes and namespaces. C# applications are written by combining new properties, methods and classes that you write with predefined properties, methods and classes available in the .NET Framework Class Library and in various other class libraries. Related classes are often grouped into namespaces and compiled into class libraries so that they can be reused in other applications. You’ll learn how to create your own namespaces and class libraries in Chapter 15. The Framework Class Library provides many predefined classes that contain methods for performing common mathematical calculations, string manipulations, character manipulations, input/output operations, database operations, networking operations, file processing, error checking, web-application development and more.

Good Programming Practice 7.1

Familiarize yourself with the classes and methods provided by the Framework Class Library (msdn.microsoft.com/en-us/library/ms229335.aspx).

Software Engineering Observation 7.1

Don’t try to “reinvent the wheel.” When possible, reuse Framework Class Library classes and methods. This reduces application development time, avoids introducing programming errors and contributes to good application performance.

Methods (called functions or procedures in other programming languages) allow you to modularize an application by separating its tasks into self-contained units. You’ve declared methods in every application you’ve written. These methods are sometimes referred to as user-defined methods. The actual statements in the method bodies are written only once, can be reused from several locations in an application and are hidden from other methods.

There are several motivations for modularizing an application by means of methods. One is the “divide-and-conquer” approach, which makes application development more manageable by constructing applications from small, simple pieces. Another is software reusability—existing methods can be used as building blocks to create new applications. Often, you can create applications mostly by reusing existing methods rather than by building customized code. For example, in earlier applications, we did not have to define how to read data values from the keyboard—the Framework Class Library provides these capabilities in class Console. A third motivation is to avoid repeating code. Dividing an application into meaningful methods makes the application easier to debug and maintain.

Software Engineering Observation 7.2

To promote software reusability, every method should be limited to performing a single, well-defined task, and the name of the method should express that task effectively. Such methods make applications easier to write, debug, maintain and modify.

Software Engineering Observation 7.3

If you cannot choose a concise name that expresses a method’s task, your method might be attempting to perform too many diverse tasks. It’s usually best to break such a method into several smaller methods.

As you know, a method is invoked by a method call, and when the called method completes its task, it returns a result or simply returns control to the caller. The code that calls a method is also sometimes known as the client code—as it’s a client of the method. An analogy to the method-call-and-return structure is the hierarchical form of management (Figure 7.1). A boss (the caller) asks a worker (the called method) to perform a task and report back (i.e., return) the results after completing the task. The boss method does not know how the worker method performs its designated tasks. The worker may also call other worker methods, unbeknown to the boss. This “hiding” of implementation details promotes good software engineering. Figure 7.1 shows the boss method communicating with several worker methods in a hierarchical manner. The boss method divides the responsibilities among the various worker methods. Note that worker1 acts as a “boss method” to worker4 and worker5.

Figure 7.1. Hierarchical boss-method/worker-method relationship.

Although most methods execute on specific objects in response to method calls, this is not always the case. Sometimes a method performs a task that does not depend on the contents of any object. Such a method applies to the class in which it’s declared as a whole and is known as a static method. It’s not uncommon for a class to contain a group of static methods to perform common tasks. For example, recall that we used static method Pow of class Math to raise a value to a power in Fig. 6.6. To declare a method as static, place the keyword static before the return type in the method’s declaration. You call any static method by specifying the name of the class in which the method is declared, followed by the member access (.) operator and the method name, as in

ClassName.MethodName( arguments )

We use various methods of the Math class here to present the concept of static methods. Class Math (from the System namespace) provides a collection of methods that enable you to perform common mathematical calculations. For example, you can calculate the square root of 900.0 with the static method call

Math.Sqrt( 900.0 )

The preceding expression evaluates to 30.0. Method Sqrt takes an argument of type double and returns a result of type double. To output the value of the preceding method call in the console window, you might write the statement

Console.WriteLine( Math.Sqrt( 900.0 ) );

In this statement, the value that Sqrt returns becomes the argument to method WriteLine. We did not create a Math object before calling method Sqrt. Also, all of Math’s methods are static—therefore, each is called by preceding the name of the method with the class name Math and the member access (.) operator. Similarly, Console method WriteLine is a static method of class Console, so we invoke the method by preceding its name with the class name Console and the member access (.) operator.

Method arguments may be constants, variables or expressions. If c = 13.0, d = 3.0 and f = 4.0, then the statement

Console.WriteLine( Math.Sqrt( c + d * f ) );

calculates and displays the square root of 13.0 + 3.0 * 4.0 = 25.0—namely, 5.0. Figure 7.2 summarizes several Math class methods. In the figure, x and y are of type double.

Math Class Constants PI and E

Class Math also declares two static constants that represent commonly used mathematical values: Math.PI and Math.E. The constant Math.PI (3.14159265358979323846) is the ratio of a circle’s circumference to its diameter. The constant Math.E (2.7182818284590452354) is the base value for natural logarithms (calculated with static Math method Log). These constants are declared in class Math with the modifiers public and const. Making them public allows other programmers to use these variables in their own classes. A constant is declared with the keyword const—its value cannot be changed after the constant is declared. Both PI and E are declared const because their values never change.

Common Programming Error 7.1

Every constant declared in a class, but not inside a method of the class is implicitly static, so it’s a syntax error to declare such a constant with keyword static explicitly.

Because these constants are static, you can access them via the class name Math and the member access (.) operator, just like class Math’s methods. Recall from Section 4.5 that when each object of a class maintains its own copy of an attribute, the variable that represents the attribute is also known as an instance variable—each object (instance) of the class has a separate instance of the variable. There are also variables for which each object of a class does not have a separate instance of the variable. That’s the case with static variables. When objects of a class containing static variables are created, all the objects of that class share one copy of the class’s static variables. Together the static variables and instance variables represent the fields of a class.

public static void Main( string args[] )

Methods often require more than one piece of information to perform their tasks. We now consider how to write your own methods with multiple parameters.

The application in Fig. 7.3 uses a user-defined method called Maximum to determine and return the largest of three double values that are input by the user. When the application begins execution, the Main method (lines 8–22) executes. Lines 11–15 prompt the user to enter three double values and read them from the user. Line 18 calls method Maximum (declared in lines 25–38) to determine the largest of the three double values passed as arguments to the method. When method Maximum returns the result to line 18, the application assigns Maximum’s return value to local variable result. Then line 21 outputs result. At the end of this section, we’ll discuss the use of operator + in line 21.

 1   // Fig. 7.3: MaximumFinder.cs
 2   // User-defined method Maximum.
 3   using System;
 4
 5   public class MaximumFinder
 6   {
 7      // obtain three floating-point values and determine maximum value
 8      public static void Main( string[] args )
 9      {
10         // prompt for and input three floating-point values
11         Console.WriteLine( "Enter three floating-point values,
"
12            + "  pressing 'Enter' after each one: " );
13         double number1 = Convert.ToDouble( Console.ReadLine() );
14         double number2 = Convert.ToDouble( Console.ReadLine() );
15         double number3 = Convert.ToDouble( Console.ReadLine() );
16
17         // determine the maximum value
18         double result = Maximum( number1, number2, number3 );
19
20         // display maximum value
21         Console.WriteLine( "Maximum is: " + result );
22      } // end Main
23
24      // returns the maximum of its three double parameters         
25      public static double Maximum( double x, double y, double z )  
26      {                                                             
27         double maximumValue = x; // assume x is the largest to start
28                                                                     
29         // determine whether y is greater than maximumValue         
30         if ( y > maximumValue )                                     
31            maximumValue = y;                                        
32                                                                     
33         // determine whether z is greater than maximumValue         
34         if ( z > maximumValue )                                     
35            maximumValue = z;                                        
36                                                                     
37         return maximumValue;                                        
38      } // end method Maximum                                        
39   } // end class MaximumFinder

Enter three floating-point values,
  pressing 'Enter' after each one:
3.33
2.22
1.11
Maximum is: 3.33

Enter three floating-point values,
  pressing 'Enter' after each one:
2.22
3.33
1.11
Maximum is: 3.33

Enter three floating-point values,
  pressing 'Enter' after each one:
1.11
2.22
867.5309
Maximum is: 867.5309

Method Maximum

Consider the declaration of method Maximum (lines 25–38). Line 25 indicates that the method returns a double value, that the method’s name is Maximum and that the method requires three double parameters (x, y and z) to accomplish its task. When a method has more than one parameter, the parameters are specified as a comma-separated list. When Maximum is called in line 18, the parameter x is initialized with the value of the argument number1, the parameter y is initialized with the value of the argument number2 and the parameter z is initialized with the value of the argument number3. There must be one argument in the method call for each required parameter (sometimes called a formal parameter) in the method declaration. Also, each argument must be consistent with the type of the corresponding parameter. For example, a parameter of type double can receive values like 7.35 (a double), 22 (an int) or –0.03456 (a double), but not strings like "hello". Section 7.7 discusses the argument types that can be provided in a method call for each parameter of a simple type.

To determine the maximum value, we begin with the assumption that parameter x contains the largest value, so line 27 declares local variable maximumValue and initializes it with the value of parameter x. Of course, it’s possible that parameter y or z contains the largest value, so we must compare each of these values with maximumValue. The if statement at lines 30–31 determines whether y is greater than maximumValue. If so, line 31 assigns y to maximumValue. The if statement at lines 34–35 determines whether z is greater than maximumValue. If so, line 35 assigns z to maximumValue. At this point, the largest of the three values resides in maximumValue, so line 37 returns that value to line 18. When program control returns to the point in the application where Maximum was called, Maximum’s parameters x, y and z are no longer accessible. Methods can return at most one value; the returned value can be a value type that contains many values (implemented as a struct) or a reference to an object that contains many values.

Variable result is a local variable in method Main because it’s declared in the block that represents the method’s body. Variables should be declared as fields of a class (i.e., as either instance variables or static variables of the class) only if they’re required for use in more than one method of the class or if the application should save their values between calls to the class’s methods.

Common Programming Error 7.2

Declaring method parameters of the same type as float x, y instead of float x, float y is a syntax error—a type is required for each parameter in the parameter list.

return Math.Max( x, Math.Max( y, z ) );

Assembling Strings with String Concatenation

C# allows string objects to be created by assembling smaller strings into larger strings using operator + (or the compound assignment operator +=). This is known as string concatenation. When both operands of operator + are string objects, operator + creates a new string object in which a copy of the characters of the right operand is placed at the end of a copy of the characters in the left operand. For example, the expression "hello " + "there" creates the string "hello there" without disturbing the original strings.

In line 21 of Fig. 7.3, the expression "Maximum is: " + result uses operator + with operands of types string and double. Every value of a simple type in C# has a string representation. When one of the + operator’s operands is a string, the other is implicitly converted to a string, then the two are concatenated. In line 21, the double value is implicitly converted to its string representation and placed at the end of the string "Maximum is: ". If there are any trailing zeros in a double value, these will be discarded when the number is converted to a string. Thus, the number 9.3500 would be represented as 9.35 in the resulting string.

For values of simple types used in string concatenation, the values are converted to strings. If a bool is concatenated with a string, the bool is converted to the string "True" or "False" (each is capitalized). All objects have a ToString method that returns a string representation of the object. When an object is concatenated with a string, the object’s ToString method is implicitly called to obtain the string representation of the object. If the object is null, an empty string is written.

Line 21 of Fig. 7.3 could also be written using string formatting as

Console.WriteLine( "Maximum is: {0}", result );

As with string concatenation, using a format item to substitute an object into a string implicitly calls the object’s ToString method to obtain the object’s string representation. You’ll learn more about method ToString in Chapter 8.

When a large string literal is typed into an application’s source code, you can break that string into several smaller strings and place them on multiple lines for readability. The strings can be reassembled using either string concatenation or string formatting. We discuss the details of strings in Chapter 16.

Common Programming Error 7.3

It’s a syntax error to break a string literal across multiple lines in an application. If a string does not fit on one line, split the string into several smaller strings and use concatenation to form the desired string.C# also provides so-called verbatim string literals, which are preceded by the @ character. Such literals can be split over multiple lines and the characters in the literal are processed exactly as they appear in the literal.

Common Programming Error 7.4

Confusing the + operator used for string concatenation with the + operator used for addition can lead to strange results. The + operator is left-associative. For example, if integer variable y has the value 5, the expression "y + 2 = " + y + 2 results in the string "y + 2 = 52", not "y + 2 = 7", because first the value of y (5) is concatenated with the string "y + 2 = ", then the value 2 is concatenated with the new larger string "y + 2 = 5". The expression "y + 2 = " + (y + 2) produces the desired result "y + 2 = 7".

You’ve seen three ways to call a method:

A static method can call only other static methods of the same class directly (i.e., using the method name by itself) and can manipulate only static variables in the same class directly. To access the class’s non-static members, a static method must use a reference to an object of the class. Recall that static methods relate to a class as a whole, whereas non-static methods are associated with a specific instance (object) of the class and may manipulate the instance variables of that object. Many objects of a class, each with its own copies of the instance variables, may exist at the same time. Suppose a static method were to invoke a non-static method directly. How would the method know which object’s instance variables to manipulate? What would happen if no objects of the class existed at the time the non-static method was invoked? Thus, C# does not allow a static method to access non-static members of the same class directly.

There are three ways to return control to the statement that calls a method. If the method does not return a result, control returns when the program flow reaches the method-ending right brace or when the statement

return;

is executed. If the method returns a result, the statement

evaluates the expression, then returns the result (and control) to the caller.

Common Programming Error 7.5

Declaring a method outside the body of a class declaration or inside the body of another method is a syntax error.

Common Programming Error 7.6

Omitting the return type in a method declaration is a syntax error.

Common Programming Error 7.7

Redeclaring a method parameter as a local variable in the method’s body is a compilation error.

Common Programming Error 7.8

Forgetting to return a value from a method that should return one is a compilation error. If a return type other than void is specified, the method must contain a return statement in each possible execution path through the method and each return statement must return a value consistent with the method’s return type. Returning a value from a method whose return type has been declared void is a compilation error.

To understand how C# performs method calls, we first need to consider a data structure (i.e., collection of related data items) known as a stack (we discuss data structures in more detail in Chapters 20–23). You can think of a stack as analogous to a pile of dishes. When a dish is placed on the pile, it’s normally placed at the top (referred to as pushing the dish onto the stack). Similarly, when a dish is removed from the pile, it’s always removed from the top (referred to as popping the dish off the stack). Stacks are known as last-in, first-out (LIFO) data structures—the last item pushed (inserted) on the stack is the first item popped off (removed from) the stack.

When an application calls a method, the called method must know how to return to its caller, so the return address of the calling method is pushed onto the program-execution stack (sometimes referred to as the method-call stack). If a series of method calls occurs, the successive return addresses are pushed onto the stack in last-in, first-out order so that each method can return to its caller.

The program-execution stack also contains the memory for the local variables used in each invocation of a method during an application’s execution. This data, stored as a portion of the program-execution stack, is known as the activation record or stack frame of the method call. When a method call is made, the activation record for it is pushed onto the program-execution stack. When the method returns to its caller, the activation record for this method call is popped off the stack, and those local variables are no longer known to the application. If a local variable holding a reference to an object is the only variable in the application with a reference to that object, when the activation record containing that local variable is popped off the stack, the object can no longer be accessed by the application and will eventually be deleted from memory during “garbage collection.” We’ll discuss garbage collection in Section 10.8.

Of course, the amount of memory in a computer is finite, so only a certain amount of memory can be used to store activation records on the program-execution stack. If more method calls occur than can have their activation records stored on the program-execution stack, an error known as a stack overflow occurs.

Another important feature of method calls is argument promotion—implicitly converting an argument’s value to the type that the method expects to receive in its corresponding parameter. For example, an application can call Math method Sqrt with an integer argument even though the method expects to receive a double argument. The statement

Console.WriteLine( Math.Sqrt( 4 ) );

correctly evaluates Math.Sqrt(4) and displays the value 2.0. Sqrt’s parameter list causes C# to convert the int value 4 to the double value 4.0 before passing the value to Sqrt. Such conversions may lead to compilation errors if C#’s promotion rules are not satisfied. The promotion rules specify which conversions are allowed—that is, which conversions can be performed without losing data. In the Sqrt example above, an int is converted to a double without changing its value. However, converting a double to an int truncates the fractional part of the double value—thus, part of the value is lost. Also, double variables can hold values much larger (and much smaller) than int variables, so assigning a double to an int can cause a loss of information when the double value doesn’t fit in the int. Converting large integer types to small integer types (e.g., long to int) can also result in changed values.

The promotion rules apply to expressions containing values of two or more simple types and to simple-type values passed as arguments to methods. Each value is promoted to the appropriate type in the expression. (Actually, the expression uses a temporary copy of each value—the types of the original values remain unchanged.) Figure 7.4 lists the simple types alphabetically and the types to which each can be promoted. Values of all simple types can also be implicitly converted to type object. We demonstrate such implicit conversions in Chapter 21, Data Structures.

By default, C# does not allow you to implicitly convert values between simple types if the target type cannot represent the value of the original type (e.g., the int value 2000000 cannot be represented as a short, and any floating-point number with digits after its decimal point cannot be represented in an integer type such as long, int or short). Therefore, to prevent a compilation error in cases where information may be lost due to an implicit conversion between simple types, the compiler requires you to use a cast operator to explicitly force the conversion. This enables you to “take control” from the compiler. You essentially say, “I know this conversion might cause loss of information, but for my purposes here, that’s fine.” Suppose you create a method Square that calculates the square of an integer and thus requires an int argument. To call Square with the whole part of a double argument named doubleValue, you’d write Square( (int) doubleValue ). This method call explicitly casts (converts) the value of doubleValue to an integer for use in method Square. Thus, if doubleValue’s value is 4.5, the method receives the value 4 and returns 16, not 20.25 (which does, unfortunately, result in the loss of information).

Common Programming Error 7.9

Converting a simple-type value to a value of another simple type may change the value if the promotion is not allowed. For example, converting a floating-point value to an integral value may introduce truncation errors (loss of the fractional part) in the result.

Many predefined classes are grouped into categories of related classes called namespaces. Together, these namespaces are referred to as the .NET Framework Class Library.

Throughout the text, using directives allow us to use library classes from the Framework Class Library without specifying their fully qualified names. For example, an application includes the declaration

using System;

in order to use the class names from the System namespace without fully qualifying their names. This allows you to use the unqualified class name Console, rather than the fully qualified class name System.Console, in your code. A great strength of C# is the large number of classes in the namespaces of the .NET Framework Class Library. Some key Framework Class Library namespaces are described in Fig. 7.5, which represents only a small portion of the reusable classes in the .NET Framework Class Library.

System.Windows.Controls
System.Windows.Input
System.Windows.Media
System.Windows.Shapes

System.Data
System.Data.Linq

System.Collections
System.Collections.Generic

The set of namespaces available in the .NET Framework Class Library is quite large. Besides those summarized in Fig. 7.5, the .NET Framework Class Library contains namespaces for complex graphics, advanced graphical user interfaces, printing, advanced networking, security, database processing, multimedia, accessibility (for people with disabilities) and many other capabilities—over 100 namespaces in all.

You can locate additional information about a predefined C# class’s methods in the .NET Framework Class Library reference (msdn.microsoft.com/en-us/library/ms229335.aspx). When you visit this site, you’ll see an alphabetical listing of all the namespaces in the Framework Class Library. Locate the namespace and click its link to see an alphabetical listing of all its classes, with a brief description of each. Click a class’s link to see a more complete description of the class. Click the Methods link in the left-hand column to see a listing of the class’s methods.

Good Programming Practice 7.2

The online .NET Framework documentation is easy to search and provides many details about each class. As you learn each class in this book, you should review the class in the online documentation for additional information.

In this and the next section, we develop a nicely structured game-playing application with multiple methods. The application uses most of the control statements presented thus far in the book and introduces several new programming concepts.

There’s something in the air of a casino that invigorates people—from the high rollers at the plush mahogany-and-felt craps tables to the quarter poppers at the one-armed bandits. It’s the element of chance, the possibility that luck will convert a pocketful of money into a mountain of wealth. The element of chance can be introduced in an application via an object of class Random (of namespace System). Objects of class Random can produce random byte, int and double values. In the next several examples, we use objects of class Random to produce random numbers.

A new random-number generator object can be created as follows:

Random randomNumbers = new Random();

The random-number generator object can then be used to generate random byte, int and double values—we discuss only random int values here.

Consider the following statement:

int randomValue = randomNumbers.Next();

Method Next of class Random generates a random int value in the range 0 to +2,147,483,646, inclusive. If the Next method truly produces values at random, then every value in that range should have an equal chance (or probability) of being chosen each time method Next is called. The values returned by Next are actually pseudorandom numbers—a sequence of values produced by a complex mathematical calculation. The calculation uses the current time of day (which, of course, changes constantly) to seed the random-number generator such that each execution of an application yields a different sequence of random values.

The range of values produced directly by method Next often differs from the range of values required in a particular C# application. For example, an application that simulates coin tossing might require only 0 for “heads” and 1 for “tails.” An application that simulates the rolling of a six-sided die might require random integers in the range 1–6. A video game that randomly predicts the next type of spaceship (out of four possibilities) that will fly across the horizon might require random integers in the range 1–4. For cases like these, class Random provides other versions of method Next. One receives an int argument and returns a value from 0 up to, but not including, the argument’s value. For example, you might use the statement

int randomValue = randomNumbers.Next( 6 );

which returns 0, 1, 2, 3, 4 or 5. The argument 6—called the scaling factor—represents the number of unique values that Next should produce (in this case, six—0, 1, 2, 3, 4 and 5). This manipulation is called scaling the range of values produced by Random method Next.

Suppose we wanted to simulate a six-sided die that has the numbers 1–6 on its faces, not 0–5. Scaling the range of values alone is not enough. So we shift the range of numbers produced. We could do this by adding a shifting value—in this case 1—to the result of method Next, as in

face = 1 + randomNumbers.Next( 6 );

The shifting value (1) specifies the first value in the desired set of random integers. The preceding statement assigns to face a random integer in the range 1–6.

The third alternative of method Next provides a more intuitive way to express both shifting and scaling. This method receives two int arguments and returns a value from the first argument’s value up to, but not including, the second argument’s value. We could use this method to write a statement equivalent to our previous statement, as in

face = randomNumbers.Next( 1, 7 );

 1   // Fig. 7.6: RandomIntegers.cs
 2   // Shifted and scaled random integers.
 3   using System;
 4
 5   public class RandomIntegers
 6   {
 7      public static void Main( string[] args )
 8      {
 9         Random randomNumbers = new Random(); // random-number generator
10         int face; // stores each random integer generated
11
12         // loop 20 times
13         for ( int counter = 1; counter <= 20; counter++ )
14         {
15            // pick random integer from 1 to 6
16            face = randomNumbers.Next( 1, 7 );
17
18            Console.Write( "{0}  ", face ); // display generated value
19
20            // if counter is divisible by 5, start a new line of output
21            if ( counter % 5 == 0 )
22               Console.WriteLine();
23         } // end for
24      } // end Main
25   } // end class RandomIntegers

3  3  3  1  1
2  1  2  4  2
2  3  6  2  5
3  4  6  6  1

6  2  5  1  3
5  2  1  6  5
4  1  6  1  3
3  1  4  3  4

 1   // Fig. 7.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
11         int frequency1 = 0; // count of 1s rolled
12         int frequency2 = 0; // count of 2s rolled
13         int frequency3 = 0; // count of 3s rolled
14         int frequency4 = 0; // count of 4s rolled
15         int frequency5 = 0; // count of 5s rolled
16         int frequency6 = 0; // count of 6s rolled
17
18         int face; // stores most recently rolled value
19
20         // summarize results of 6000 rolls of a die
21         for ( int roll = 1; roll <= 6000; roll++ )
22         {
23            face = randomNumbers.Next( 1, 7 ); // number from 1 to 6
24
25            // determine roll value 1-6 and increment appropriate counter
26            switch ( face )
27            {
28               case 1:
29                  ++frequency1; // increment the 1s counter
30                  break;
31               case 2:
32                  ++frequency2; // increment the 2s counter
33                  break;
34               case 3:
35                  ++frequency3; // increment the 3s counter
36                  break;
37               case 4:
38                  ++frequency4; // increment the 4s counter
39                  break;
40               case 5:
41                  ++frequency5; // increment the 5s counter
42                  break;
43               case 6:
44                  ++frequency6; // increment the 6s counter
45                  break;
46            } // end switch
47         } // end for
48
49         Console.WriteLine( "Face	Frequency" ); // output headers
50         Console.WriteLine(
51            "1	{0}
2	{1}
3	{2}
4	{3}
5	{4}
6	{5}", frequency1,
52            frequency2, frequency3, frequency4, frequency5, frequency6 );
53      } // end Main
54   } // end class RollDie

Face      Frequency
1         1039
2         994
3         991
4         970
5         978
6         1028

Face      Frequency
1         985
2         985
3         1001
4         1017
5         1002
6         1010

face = randomNumbers.Next( 1, 7 );

number = randomNumbers.Next( shiftingValue, shiftingValue + scalingFactor );

number = 2 + 3 * randomNumbers.Next( 5 );

number = shiftingValue +
   differenceBetweenValues * randomNumbers.Next( scalingFactor );

Random-Number Repeatability for Testing and Debugging

As we mentioned earlier in Section 7.9, the methods of class Random actually generate pseudorandom numbers based on complex mathematical calculations. Repeatedly calling any of Random’s methods produces a sequence of numbers that appears to be random. The calculation that produces the pseudorandom numbers uses the time of day as a seed value to change the sequence’s starting point. Each new Random object seeds itself with a value based on the computer system’s clock at the time the object is created, enabling each execution of an application to produce a different sequence of random numbers.

When debugging an application, it’s sometimes useful to repeat the exact same sequence of pseudorandom numbers during each execution of the application. This repeatability enables you to prove that your application is working for a specific sequence of random numbers before you test the application with different sequences of random numbers. When repeatability is important, you can create a Random object as follows:

Random randomNumbers = new Random( seedValue );

The seedValue argument (type int) seeds the random-number calculation. If the same seedValue is used every time, the Random object produces the same sequence of random numbers.

Error-Prevention Tip 7.1

While an application is under development, create the Random object with a specific seed value to produce a repeatable sequence of random numbers each time the application executes. If a logic error occurs, fix the error and test the application again with the same seed value—this allows you to reconstruct the same sequence of random numbers that caused the error. Once the logic errors have been removed, create the Random object without using a seed value, causing the Random object to generate a new sequence of random numbers each time the application executes.

One popular game of chance is the dice game known as “craps,” which is played in casinos and back alleys throughout the world. The rules of the game are straightforward:

The application in Fig. 7.8 simulates the game of craps, using methods to define the logic of the game. The Main method (lines 24–70) calls the static RollDice method (lines 73–85) as needed to roll the two dice and compute their sum. The four sample outputs show winning on the first roll, losing on the first roll, winning on a subsequent roll and losing on a subsequent roll, respectively. Variable randomNumbers (line 8) is declared static so it can be created once during the program’s execution and used in method RollDice.

 1   // Fig. 7.8: Craps.cs
 2   // Craps class simulates the dice game craps.
 3   using System;
 4
 5   public class Craps
 6   {
 7      // create random-number generator for use in method RollDice
 8      private static Random randomNumbers = new Random();
 9
10      // enumeration with constants that represent the game status
11      private enum Status { CONTINUE, WON, LOST }                 
12
13      // enumeration with constants that represent common rolls of the dice
14      private enum DiceNames
15      {                     
16         SNAKE_EYES = 2,     
17         TREY = 3,           
18         SEVEN = 7,          
19         YO_LEVEN = 11,      
20         BOX_CARS = 12       
21      }                      
22
23      // plays one game of craps
24      public static void Main( string[] args )
25      {
26         // gameStatus can contain CONTINUE, WON or LOST
27         Status gameStatus = Status.CONTINUE;
28         int myPoint = 0; // point if no win or loss on first roll
29
30         int sumOfDice = RollDice(); // first roll of the dice
31
32         // determine game status and point based on first roll
33         switch ( ( DiceNames ) sumOfDice )
34         {
35            case DiceNames.SEVEN: // win with 7 on first roll    
36            case DiceNames.YO_LEVEN: // win with 11 on first roll
37               gameStatus = Status.WON;                          
38               break;
39            case DiceNames.SNAKE_EYES: // lose with 2 on first roll
40            case DiceNames.TREY: // lose with 3 on first roll      
41            case DiceNames.BOX_CARS: // lose with 12 on first roll 
42               gameStatus = Status.LOST;                           
43               break;
44            default: // did not win or lose, so remember point  
45               gameStatus = Status.CONTINUE; // game is not over
46               myPoint = sumOfDice; // remember the point       
47               Console.WriteLine( "Point is {0}", myPoint );    
48               break;
49         } // end switch
50
51         // while game is not complete
52         while ( gameStatus == Status.CONTINUE ) // game not WON or LOST
53         {
54            sumOfDice = RollDice(); // roll dice again
55
56            // determine game status
57            if ( sumOfDice == myPoint ) // win by making point
58               gameStatus = Status.WON;
59            else
60               // lose by rolling 7 before point
61               if ( sumOfDice == ( int ) DiceNames.SEVEN )
62                  gameStatus = Status.LOST;
63         } // end while
64
65         // display won or lost message
66         if ( gameStatus == Status.WON )
67            Console.WriteLine( "Player wins" );
68         else
69            Console.WriteLine( "Player loses" );
70      } // end Main
71
72      // roll dice, calculate sum and display results
73      public static int RollDice()
74      {
75         // pick random die values
76         int die1 = randomNumbers.Next( 1, 7 ); // first die roll
77         int die2 = randomNumbers.Next( 1, 7 ); // second die roll
78
79         int sum = die1 + die2; // sum of die values
80
81         // display results of this roll
82         Console.WriteLine( "Player rolled {0} + {1} = {2}",
83            die1, die2, sum );
84         return sum; // return sum of dice
85      } // end method RollDice
86   } // end class Craps

Player rolled 2 + 5 = 7
Player wins

Player rolled 2 + 1 = 3
Player loses

Player rolled 4 + 6 = 10
Point is 10
Player rolled 1 + 3 = 4
Player rolled 1 + 3 = 4
Player rolled 2 + 3 = 5
Player rolled 4 + 4 = 8
Player rolled 6 + 6 = 12
Player rolled 4 + 4 = 8
Player rolled 4 + 5 = 9
Player rolled 2 + 6 = 8
Player rolled 6 + 6 = 12
Player rolled 6 + 4 = 10
Player wins

Player rolled 2 + 4 = 6
Point is 6
Player rolled 3 + 1 = 4
Player rolled 5 + 5 = 10
Player rolled 6 + 1 = 7
Player loses

enum Type Status

Local variable gameStatus is declared to be of a new type called Status, which we declared in line 11. Type Status is declared as a private member of class Craps, because Status will be used only in that class. Status is a user-defined type called an enumeration, which declares a set of constants represented by identifiers. An enumeration is introduced by the keyword enum and a type name (in this case, Status). As with a class, braces ( { and }) delimit the body of an enum declaration. Inside the braces is a comma-separated list of enumeration constants. The enum constant names must be unique, but the value associated with each constant need not be.

Good Programming Practice 7.3

Use only uppercase letters in the names of constants. This makes the constants stand out in an application and reminds you that enumeration constants are not variables.

Variables of type Status should be assigned only one of the three constants declared in the enumeration. When the game is won, the application sets local variable gameStatus to Status.WON (lines 37 and 58). When the game is lost, the application sets local variable gameStatus to Status.LOST (lines 42 and 62). Otherwise, the application sets local variable gameStatus to Status.CONTINUE (line 45) to indicate that the dice must be rolled again.

Good Programming Practice 7.4

Using enumeration constants (like Status.WON, Status.LOST and Status.CONTINUE) rather than literal integer values (such as 0, 1 and 2) can make code easier to read and maintain.

private enum MyEnum : typeName { Constant1, Constant2, ... }

You’ve seen declarations of C# entities, such as classes, methods, properties, variables and parameters. Declarations introduce names that can be used to refer to such C# entities. The scope of a declaration is the portion of the application that can refer to the declared entity by its unqualified name. Such an entity is said to be “in scope” for that portion of the application. This section introduces several important scope issues. The basic scope rules are as follows:

Any block may contain variable declarations. If a local variable or parameter in a method has the same name as a field, the field is hidden until the block terminates. In Chapter 10, we discuss how to access hidden fields. The application in Fig. 7.9 demonstrates scoping issues with fields and local variables.

 1   // Fig. 7.9: Scope.cs
 2   // Scope class demonstrates static and local variable scopes.
 3   using System;
 4
 5   public class Scope
 6   {
 7      // static variable that is accessible to all methods of this class
 8      private static int x = 1;                                         
 9
10      // Main creates and initializes local variable x
11      // and calls methods UseLocalVariable and UseStaticVariable
12      public static void Main( string[] args )
13      {
14         int x = 5; // method's local variable x hides static variable x
15
16         Console.WriteLine( "local x in method Main is {0}", x );
17
18         // UseLocalVariable has its own local x
19         UseLocalVariable();
20
21         // UseStaticVariable uses class Scope's static variable x
22         UseStaticVariable();
23
24         // UseLocalVariable reinitializes its own local x
25         UseLocalVariable();
26
27         // class Scope's static variable x retains its value
28         UseStaticVariable();
29
30         Console.WriteLine( "
local x in method Main is {0}", x );
31      } // end Main
32
33      // create and initialize local variable x during each call
34      public static void UseLocalVariable()
35      {
36         int x = 25; // initialized each time UseLocalVariable is called
37
38         Console.WriteLine(
39            "
local x on entering method UseLocalVariable is {0}", x );
40         ++x; // modifies this method's local variable x
41         Console.WriteLine(
42            "local x before exiting method UseLocalVariable is {0}", x );
43      } // end method UseLocalVariable
44
45      // modify class Scope's static variable x during each call
46      public static void UseStaticVariable()
47      {
48         Console.WriteLine( "
static variable x on entering {0} is {1}",
49            "method UseStaticVariable", x );
50         x *= 10; // modifies class Scope's static variable x
51         Console.WriteLine( "static variable x before exiting {0} is {1}",
52            "method UseStaticVariable", x );
53      } // end method UseStaticVariable
54   } // end class Scope

local x in method Main is 5

local x on entering method UseLocalVariable is 25
local x before exiting method UseLocalVariable is 26

static variable x on entering method UseStaticVariable is 1
static variable x before exiting method UseStaticVariable is 10

local x on entering method UseLocalVariable is 25
local x before exiting method UseLocalVariable is 26

static variable x on entering method UseStaticVariable is 10
static variable x before exiting method UseStaticVariable is 100

local x in method Main is 5

Error-Prevention Tip 7.2

Use different names for fields and local variables to help prevent subtle logic errors that occur when a method is called and a local variable of the method hides a field of the same name in the class.

Line 8 declares and initializes the static variable x to 1. This static variable is hidden in any block (or method) that declares local variable named x. Method Main (lines 12–31) declares local variable x (line 14) and initializes it to 5. This local variable’s value is output to show that static variable x (whose value is 1) is hidden in method Main. The application declares two other methods—UseLocalVariable (lines 34–43) and UseStaticVariable (lines 46–53)—that each take no arguments and do not return results. Method Main calls each method twice (lines 19–28). Method UseLocalVariable declares local variable x (line 36). When UseLocalVariable is first called (line 19), it creates local variable x and initializes it to 25 (line 36), outputs the value of x (lines 38–39), increments x (line 40) and outputs the value of x again (lines 41–42). When UseLocalVariable is called a second time (line 25), it re-creates local variable x and reinitializes it to 25, so the output of each UseLocalVariable call is identical.

Method UseStaticVariable does not declare any local variables. Therefore, when it refers to x, static variable x (line 8) of the class is used. When method UseStaticVariable is first called (line 22), it outputs the value (1) of static variable x (lines 48–49), multiplies the static variable x by 10 (line 50) and outputs the value (10) of static variable x again (lines 51–52) before returning. The next time method UseStaticVariable is called (line 28), the static variable has its modified value, 10, so the method outputs 10, then 100. Finally, in method Main, the application outputs the value of local variable x again (line 30) to show that none of the method calls modified Main’s local variable x, because the methods all referred to variables named x in other scopes.

Methods of the same name can be declared in the same class, as long as they have different sets of parameters (determined by the number, types and order of the parameters). This is called method overloading. When an overloaded method is called, the C# compiler selects the appropriate method by examining the number, types and order of the arguments in the call. Method overloading is commonly used to create several methods with the same name that perform the same or similar tasks, but on different types or different numbers of arguments. For example, Math methods Min and Max (summarized in Section 7.3) are overloaded with 11 versions. These find the minimum and maximum, respectively, of two values of each of the 11 numeric simple types. Our next example demonstrates declaring and invoking overloaded methods. You’ll see examples of overloaded constructors in Chapter 10.

 1   // Fig. 7.10: MethodOverload.cs
 2   // Overloaded method declarations.
 3   using System;
 4
 5   public class MethodOverload
 6   {
 7      // test overloaded square methods
 8      public static void Main( string[] args )
 9      {
10         Console.WriteLine( "Square of integer 7 is {0}", Square( 7 ) );
11         Console.WriteLine( "Square of double 7.5 is {0}", Square( 7.5 ) );
12      } // end Main
13
14      // square method with int argument                           
15      public static int Square( int intValue )                     
16      {                                                            
17         Console.WriteLine( "Called square with int argument: {0}",
18            intValue );                                            
19         return intValue * intValue;                               
20      } // end method Square with int argument                     
21
22      // square method with double argument                           
23      public static double Square( double doubleValue )               
24      {                                                               
25         Console.WriteLine( "Called square with double argument: {0}",
26            doubleValue );                                            
27         return doubleValue * doubleValue;                            
28      } // end method Square with double argument                     
29   } // end class MethodOverload

Called square with int argument: 7
Square of integer 7 is 49
Called square with double argument: 7.5
Square of double 7.5 is 56.25

void Method1( int a, float b )

void Method1( float a, int b )

Return Types of Overloaded Methods

In discussing the logical names of methods used by the compiler, we did not mention the return types of the methods. This is because method calls cannot be distinguished by return type. The application in Fig. 7.11 illustrates the compiler errors generated when two methods have the same signature but different return types. Overloaded methods can have the same or different return types if the methods have different parameter lists. Also, overloaded methods need not have the same number of parameters.

Example 7.11. Overloaded methods with identical signatures cause compilation errors, even if return types are different.

 1   // Fig. 7.11: MethodOverload.cs
 2   // Overloaded methods with identical signatures
 3   // cause compilation errors, even if return types are different.
 4   public class MethodOverloadError
 5   {
 6      // declaration of method Square with int argument
 7      public int Square( int x )
 8      {
 9         return x * x;
10      } // end method Square
11
12      // second declaration of method Square with int argument
13      // causes compilation error even though return types are different
14      public double Square( int y )
15      {
16         return y * y;
17      } // end method Square
18   } // end class MethodOverloadError

Common Programming Error 7.10

Declaring overloaded methods with identical parameter lists is a compilation error regardless of whether the return types are different.

As of Visual C# 2010, methods can have optional parameters that allow the calling method to vary the number of arguments to pass. An optional parameter specifies a default value that’s assigned to the parameter if the optional argument is omitted.

You can create methods with one or more optional parameters. All optional parameters must be placed to the right of the method’s non-optional parameters—that is, at the end of the parameter list.

Common Programming Error 7.11

Declaring a non-optional parameter to the right of an optional one is a compilation error.

When a parameter has a default value, the caller has the option of passing that particular argument. For example, the method header

public int Power( int baseValue, int exponentValue = 2 )

specifies an optional second parameter. Any call to Power must pass at least an argument for the parameter baseValue, or a compilation error occurs. Optionally, a second argument (for the exponentValue parameter) can be passed to Power. Consider the following calls to Power:

Power()
Power(10)
Power(10, 3)

The first call generates a compilation error because this method requires a minimum of one argument. The second call is valid because one argument (10) is being passed—the optional exponentValue is not specified in the method call. The last call is also valid—10 is passed as the required argument and 3 is passed as the optional argument.

In the call that passes only one argument (10), parameter exponentValue defaults to 2, which is the default value specified in the method’s header. Each optional parameter must specify a default value by using an equal (=) sign followed by the value. For example, the header for Power sets 2 as exponentValue’s default value.

Figure 7.12 demonstrates an optional parameter. The program calculates the result of raising a base value to an exponent. Method Power (Fig. 7.12, lines 15–23) specifies that its second parameter is optional. In method DisplayPowers, lines 10–11 of Fig. 7.12 call method Power. Line 10 calls the method without the optional second argument. In this case, the compiler provides the second argument, 2, using the default value of the optional argument, which is not visible to you in the call.

 1   // Fig. 7.12: Power.vb
 2   // Optional argument demonstration with method Power.
 3   using System;
 4
 5   class CalculatePowers
 6   {
 7      // call Power with and without optional arguments
 8      public static void Main( string[] args )
 9      {
10         Console.WriteLine( "Power(10) = {0}", Power( 10 ) ) ;
11         Console.WriteLine( "Power(2, 10) = {0}", Power( 2, 10 ) );
12      } // end Main
13
14      // use iteration to calculate power
15      public int Power( int baseValue, int exponentValue = 2 )
16      {
17         int result = 1; // initialize total
18
19         for ( int i = 1; i <= exponentValue; i++ )
20            result *= baseValue;
21
22         return result;
23      } // end method Power
24   } // end class CalculatePowers

Power(10) = 100
Power(2, 10) = 1024

Normally, when calling a method that has optional parameters, the argument values—in order—are assigned to the parameters from left to right in the parameter list. Consider a Time class that stores the time of day in 24-hour clock format as int values representing the hour (0–23), minute (0–59) and second (0–59). Such a class might provide a SetTime method with optional parameters like

public void SetTime( int hour = 0, int minute = 0, int second = 0 )

In the preceding method header, all of three of SetTime’s parameters are optional. Assuming that we have a Time object named t, we can call SetTime as follows:

t.SetTime(); // sets the time to 12:00:00 AM
t.SetTime( 12 ); // sets the time to 12:00:00 PM
t.SetTime( 12, 30 ); // sets the time to 12:30:00 PM
t.SetTime( 12, 30, 22 ); // sets the time to 12:30:22 PM

In the first call, no arguments are specified, so the compiler assigns 0 to each parameter. In the second call, the compiler assigns the argument, 12, to the first parameter, hour, and assigns default values of 0 to the minute and second parameters. In the third call, the compiler assigns the two arguments, 12 and 30, to the parameters hour and minute, respectively, and assigns the default value 0 to the parameter second. In the last call, the compiler assigns the three arguments, 12, 30 and 22, to the parameters hour, minute and second, respectively.

What if you wanted to specify only arguments for the hour and second? You might think that you could call the method as follows:

t.SetTime( 12, , 22 ); // COMPILATION ERROR

Unlike some programming languages, C# doesn’t allow you to skip an argument as shown in the preceding statement. However, Visual C# 2010 provides a new feature called named parameters, which enable you to call methods that receive optional parameters by providing only the optional arguments you wish to specify. To do so, you explicitly specify the parameter’s name and value—separated by a colon (:)—in the argument list of the method call. For example, the preceding statement can be implemented in Visual C# 2010 as follows:

t.SetTime( hour: 12, second: 22 ); // sets the time to 12:00:22

In this case, the compiler assigns parameter hour the argument 12 and parameter second the argument 22. The parameter minute is not specified, so the compiler assigns it the default value 0. It’s also possible to specify the arguments out of order when using named parameters. The arguments for the required parameters must always be supplied.

The applications we’ve discussed thus far are generally structured as methods that call one another in a disciplined, hierarchical manner. For some problems, however, it’s useful to have a method call itself. A recursive method is a method that calls itself, either directly or indirectly through another method.

We consider recursion conceptually first. Then we examine an application containing a recursive method. Recursive problem-solving approaches have a number of elements in common. When a recursive method is called to solve a problem, it actually is capable of solving only the simplest case(s), or base case(s). If the method is called with a base case, it returns a result. If the method is called with a more complex problem, it divides the problem into two conceptual pieces: a piece that the method knows how to do and a piece that it does not know how to do. To make recursion feasible, the latter piece must resemble the original problem, but be a slightly simpler or slightly smaller version of it. Because this new problem looks like the original problem, the method calls a fresh copy of itself to work on the smaller problem; this is referred to as a recursive call and is also called the recursion step. The recursion step normally includes a return statement, because its result will be combined with the portion of the problem the method knew how to solve to form a result that will be passed back to the original caller.

The recursion step executes while the original call to the method is still active (i.e., while it has not finished executing). The recursion step can result in many more recursive calls, as the method divides each new subproblem into two conceptual pieces. For the recursion to terminate eventually, each time the method calls itself with a slightly simpler version of the original problem, the sequence of smaller and smaller problems must converge on the base case. At that point, the method recognizes the base case and returns a result to the previous copy of the method. A sequence of returns ensues until the original method call returns the result to the caller. This process sounds complex compared with the conventional problem solving we’ve performed to this point.

Recursive Factorial Calculations

As an example of recursion concepts at work, let’s write a recursive application to perform a popular mathematical calculation. Consider the factorial of a nonnegative integer n, written n! (and pronounced “n factorial”), which is the product

n · (n – 1) · (n – 2) · ... · 1

1! is equal to 1 and 0! is defined to be 1. For example, 5! is the product 5 · 4 · 3 · 2 · 1, which is equal to 120.

The factorial of an integer, number, greater than or equal to 0 can be calculated iteratively (nonrecursively) using the for statement as follows:

factorial = 1; for ( int counter = number; counter >= 1; counter-- ) factorial *= counter;

A recursive declaration of the factorial method is arrived at by observing the following relationship:

n! = n · (n – 1)!

For example, 5! is clearly equal to 5 · 4!, as is shown by the following equations:

5! = 5 · 4 · 3 · 2 · 1 5! = 5 · (4 · 3 · 2 · 1) 5! = 5 · (4!)

The evaluation of 5! would proceed as shown in Fig. 7.13. Figure 7.13(a) shows how the succession of recursive calls proceeds until 1! is evaluated to be 1, which terminates the recursion. Figure 7.13(b) shows the values returned from each recursive call to its caller until the value is calculated and returned.

Figure 7.13. Recursive evaluation of 5!.

Figure 7.14 uses recursion to calculate and display the factorials of the integers from 0 to 10. The recursive method Factorial (lines 16–24) first tests to determine whether a terminating condition (line 19) is true. If number is less than or equal to 1 (the base case), Factorial returns 1, no further recursion is necessary and the method returns. If number is greater than 1, line 23 expresses the problem as the product of number and a recursive call to Factorial evaluating the factorial of number - 1, which is a slightly simpler problem than the original calculation, Factorial( number ).

Example 7.14. Recursive Factorial method.

 1   // Fig. 7.14: FactorialTest.cs
 2   // Recursive Factorial method.
 3   using System;
 4
 5   public class FactorialTest
 6   {
 7      public static void Main( string[] args )
 8      {
 9         // calculate the factorials of 0 through 10
10         for ( long counter = 0; counter <= 10; counter++ )
11            Console.WriteLine( "{0}! = {1}",
12               counter, Factorial( counter ) );
13      } // end Main
14
15      // recursive declaration of method Factorial
16      public static long Factorial( long number )
17      {
18         // base case
19         if ( number <= 1 )
20            return 1;
21         // recursion step
22         else
23            return number * Factorial( number - 1 );
24      } // end method Factorial
25   } // end class FactorialTest

0! = 1 1! = 1 2! = 2 3! = 6 4! = 24 5! = 120 6! = 720 7! = 5040 8! = 40320 9! = 362880 10! = 3628800

Method Factorial (lines 16–24) receives a parameter of type long and returns a result of type long. As you can see in Fig. 7.14, factorial values become large quickly. We chose type long (which can represent relatively large integers) so that the application could calculate factorials greater than 20!. Unfortunately, the Factorial method produces large values so quickly that factorial values soon exceed even the maximum value that can be stored in a long variable. Due to the restrictions on the integral types, variables of type float, double or decimal might ultimately be needed to calculate factorials of larger numbers. This situation points to a weakness in many programming languages—the languages are not easily extended to handle the unique requirements of various applications. As you know, C# allows you to create a type that supports arbitrarily large integers if you wish. For example, you could create a HugeInteger class (which we ask you to do in Exercise 10.10) that would enable an application to calculate the factorials of arbitrarily large numbers. You can also use the new type BigInteger from the .NET Framework’s class library.

Common Programming Error 7.12

Either omitting the base case or writing the recursion step incorrectly so that it does not converge on the base case will cause infinite recursion, eventually exhausting memory. This error is analogous to the problem of an infinite loop in an iterative (nonrecursive) solution.

Two ways to pass arguments to functions in many programming languages are pass-by-value and pass-by-reference. When an argument is passed by value (the default in C#), a copy of its value is made and passed to the called function. Changes to the copy do not affect the original variable’s value in the caller. This prevents the accidental side effects that so greatly hinder the development of correct and reliable software systems. Each argument that has been passed in the programs in this chapter so far has been passed by value. When an argument is passed by reference, the caller gives the method the ability to access and modify the caller’s original variable.

Software Engineering Observation 7.4

Pass-by-reference can weaken security, because the called function can corrupt the caller’s data.

To pass an object by reference into a method, simply provide as an argument in the method call the variable that refers to the object. Then, in the method body, reference the object using the parameter name. The parameter refers to the original object in memory, so the called method can access the original object directly.

Previously, we discussed the difference between value types and reference types. A major difference between them is that value-type variables store values, so specifying a value-type variable in a method call passes a copy of that variable’s value to the method. Reference-type variables store references to objects, so specifying a reference-type variable as an argument passes the method a copy of the actual reference that refers to the object. Even though the reference itself is passed by value, the method can still use the reference it receives to interact with—and possibly modify—the original object. Similarly, when returning information from a method via a return statement, the method returns a copy of the value stored in a value-type variable or a copy of the reference stored in a reference-type variable. When a reference is returned, the calling method can use that reference to interact with the referenced object.

Demonstrating ref, out and Value Parameters

The application in Fig. 7.15 uses the ref and out keywords to manipulate integer values. The class contains three methods that calculate the square of an integer. Method SquareRef (lines 37–40) multiplies its parameter x by itself and assigns the new value to x. SquareRef’s parameter is declared as ref int, which indicates that the argument passed to this method must be an integer that’s passed by reference. Because the argument is passed by reference, the assignment at line 39 modifies the original argument’s value in the caller.

Example 7.15. Reference, output and value parameters.

 1   // Fig. 7.15: ReferenceAndOutputParameters.cs
 2   // Reference, output and value parameters.
 3   using System;
 4
 5   class ReferenceAndOutputParameters
 6   {
 7      // call methods with reference, output and value parameters
 8      public static void Main( string[] args )
 9      {
10         int y = 5; // initialize y to 5
11         int z; // declares z, but does not initialize it
12
13         // display original values of y and z
14         Console.WriteLine( "Original value of y: {0}", y );
15         Console.WriteLine( "Original value of z: uninitialized
" );
16
17         // pass y and z by reference               
18         SquareRef( ref y ); // must use keyword ref
19         SquareOut( out z ); // must use keyword out
20
21         // display values of y and z after they are modified by
22         // methods SquareRef and SquareOut, respectively
23         Console.WriteLine( "Value of y after SquareRef: {0}", y );
24         Console.WriteLine( "Value of z after SquareOut: {0}
", z );
25
26         // pass y and z by value
27         Square( y );
28         Square( z );
29
30         // display values of y and z after they are passed to method Square
31         // to demonstrate that arguments passed by value are not modified
32         Console.WriteLine( "Value of y after Square: {0}", y );
33         Console.WriteLine( "Value of z after Square: {0}", z );
34      } // end Main
35
36      // uses reference parameter x to modify caller's variable
37      static void SquareRef( ref int x )
38      {
39         x = x * x; // squares value of caller's variable
40      } // end method SquareRef
41
42      // uses output parameter x to assign a value
43      // to an uninitialized variable
44      static void SquareOut( out int x )
45      {
46         x = 6; // assigns a value to caller's variable
47         x = x * x; // squares value of caller's variable
48      } // end method SquareOut
49
50      // parameter x receives a copy of the value passed as an argument,
51      // so this method cannot modify the caller's variable
52      static void Square( int x )
53      {
54         x = x * x;
55      } // end method Square
56   } // end class ReferenceAndOutputParameters

Original value of y: 5 Original value of z: uninitialized Value of y after SquareRef: 25 Value of z after SquareOut: 36 Value of y after Square: 25 Value of z after Square: 36

Method SquareOut (lines 44–48) assigns its parameter the value 6 (line 46), then squares that value. SquareOut’s parameter is declared as out int, which indicates that the argument passed to this method must be an integer that’s passed by reference and that the argument does not need to be initialized in advance.

Method Square (lines 52–55) multiplies its parameter x by itself and assigns the new value to x. When this method is called, a copy of the argument is passed to the parameter x. Thus, even though parameter x is modified in the method, the original value in the caller is not modified.

Method Main (lines 8–34) invokes methods SquareRef, SquareOut and Square. We begin by initializing variable y to 5 and declaring, but not initializing, variable z. Lines 18–19 call methods SquareRef and SquareOut. Notice that when you pass a variable to a method with a reference parameter, you must precede the argument with the same keyword (ref or out) that was used to declare the reference parameter. Lines 23–24 display the values of y and z after the calls to SquareRef and SquareOut. Notice that y has been changed to 25 and z has been set to 36.

Lines 27–28 call method Square with y and z as arguments. In this case, both variables are passed by value—only copies of their values are passed to Square. As a result, the values of y and z remain 25 and 36, respectively. Lines 32–33 output the values of y and z to show that they were not modified.

Common Programming Error 7.13

The ref and out arguments in a method call must match the parameters specified in the method declaration; otherwise, a compilation error occurs.

Software Engineering Observation 7.5

By default, C# does not allow you to choose whether to pass each argument by value or by reference. Value types are passed by value. Objects are not passed to methods; rather, references to objects are passed to methods. The references themselves are passed by value. When a method receives a reference to an object, the method can manipulate the object directly, but the reference value cannot be changed to refer to a new object. In Section 8.8, you’ll see that references also can be passed by reference.

In this chapter, we discussed the difference between non-static and static methods, and we showed how to call static methods by preceding the method name with the name of the class in which it appears and the member access (.) operator. You saw that the Math class in the .NET Framework Class Library provides many static methods to perform mathematical calculations. We presented several commonly used Framework Class Library namespaces. You learned how to use operator + to perform string concatenations. You also learned how to declare constant values in two ways—with the const keyword and with enum types. We demonstrated simulation techniques and used class Random to generate sets of random numbers. We discussed the scope of fields and local variables in a class. You saw how to overload methods in a class by providing methods with the same name but different signatures. You learned how to use optional and named parameters. We discussed how recursive methods call themselves, breaking larger problems into smaller subproblems until eventually the original problem is solved. You learned the differences between value types and reference types with respect to how they’re passed to methods, and how to use the ref and out keywords to pass arguments by reference.

In Chapter 8, you’ll learn how to maintain lists and tables of data in arrays. You’ll see a more elegant implementation of the application that rolls a die 6000 times and two enhanced versions of our GradeBook case study. You’ll also learn how to access an application’s command-line arguments that are passed to method Main when a console application begins execution.