Microsoft® Visual C#® .NET Deluxe Learning Edition-Version 2003

Author Microsoft Corporation Pages 672 Disk 6 Companion CD(s) Level Beg/Int Published 05/07/2003 ISBN 9780735619104 Price $119.99 To see this book's discounted price, select a reseller below.	More Information About the Book Table of Contents Sample Chapter Index Related Series Related Books About the Author Support: Book & CD Rate this book

Chapter 3: Writing Methods and Applying Scope

• Declaring Methods
• Specifying the Method Declaration Syntax
• Writing return Statements
• Calling Methods
• Specifying the Method Call Syntax
• Understanding Scope
• Creating Local Scope with a Method
• Creating Class Scope with a Class
• Overloading Identifiers
• Writing and Calling Methods
• Chapter 3 Quick Reference

Chapter 3 Writing Methods and Applying Scope

In Chapter 2, you learned how to declare variables, how to create expressions using operators, and how precedence and associativity control expressions containing multiple operators. In this chapter, you'll learn all about methods. You'll also learn how to use arguments and parameters to pass information to a method and how to return information from a method using return statements. Finally, you'll see how to step in and out of methods using the Microsoft Visual Studio .NET integrated debugger. This information is useful when you need to trace the execution of your methods because they do not work quite as you expected.

Declaring Methods

Specifying the Method Declaration Syntax

returnType  methodName ( parameterList ) 
{ 
    // method body statements go here 
}

• The returnType is the name of a type and specifies what kind of information the method returns. This can be the name of any type, such as int or string. If you're writing a method that does not return a value, you must use the keyword void in place of the return type.
• The methodName is the name used to call the method. Method names must follow the same identifier rules as variable names. For example, addValues is a valid method name, whereas add$Values is not valid. For now, you should use camelCase for method names, and you should make method names descriptive—start with a verb, such as displayCustomer.
• The parameterList is optional and describes the types and names of the information that the method accepts. You write the parameters between the left and right parentheses as though you're declaring variables: name of the type, followed by the name of the parameter. If the method you're writing has two or more parameters, you must separate them with commas.
• The method body statements are the lines of code that are run when the method is called. They are enclosed in an opening curly brace ({) and a closing curly brace (}).

Here's the definition of a method called addValues that returns an int and has two int parameters called lhs and rhs (short for left-hand side and right-hand side, respectively):

int addValues(int lhs, int rhs) 
{ 
    // ...
    // method body statements go here 
    // ...
}

Here's the definition of a method called showResult that does not return a value and has a single int parameter called answer:

void showResult(int answer)
{
    // ...
}

Notice that you use the keyword void to indicate that the method does not return anything.

Writing return Statements

int addValues(int lhs, int rhs) 
{ 
    // ... 
    return lhs + rhs;
}

The return statement should be at the end of your method because it causes the method to finish. Any statements after the return statement will not be executed (though the compiler will warn you about this problem if you put statements after the return statement).

If you don't want your method to return information (its return type is void), you can use a variation of the return statement to cause an immediate exit from the method. You write the keyword return, immediately followed by a semicolon. For example:

void showResult(int answer) 
{ 
     
    if (...)
        return;
    
} 

If your method does not return anything, you can also omit the return statement because the method will finish automatically when execution arrives at the closing curly brace at the end of the method. Although this practice is common, it is not always considered good style. Methods that return a value must contain a return statement.

In the following exercise, you will examine another version of the MathsOperators application from Chapter 2. This version has been improved by the careful use of some small methods.

Calling Methods

Specifying the Method Call Syntax

methodName ( argumentList )

• The methodName must exactly match the name of the method you're calling. Remember, C# is a case-sensitive language.
• The argumentList supplies the optional information that the method accepts. You must supply an argument for each parameter, and the value of each argument must be compatible with the type of its corresponding parameter. If the method you're calling has two or more parameters, you must separate the arguments with commas.

Here is the addValues method:

int addValues(int lhs, int rhs) 
{ 
    // ... 
}

The addValues method has two int parameters, so you must call it with two comma-separated int arguments:

addValues(39, 3)     // okay

If you try to call addValues in some other way, you will probably not succeed:

addValues            // compile time error, no parentheses
addValues()          // compile time error, not enough arguments
addValues(39)        // compile time error, not enough arguments
addValues("39", "3") // compile time error, wrong types

The addValues method returns an int value. This int value can be used wherever an int value can be used. Consider this example:

result = addValues(39, 3);    // on right hand side of an assignment
showResult(addValues(39, 3)); // as argument to another method call

The following exercise continues using the MathsOperators application that was introduced in Chapter 2. This time you will examine some method calls.

Understanding Scope

If an identifier can be used at a particular location in a program, the identifier is said to be in scope at that location. To put it another way, the scope of an identifier is simply the region of the program in which that identifier is usable. Scope applies to methods as well as variables. The scope of an identifier is linked to the location of the declaration that introduces the identifier into the program, as you'll now learn.

Creating Local Scope with a Method

class Example
{
    void method()
    {
        int variable;
        
    }
    void anotherMethod()
    {
        variable = 42; // compile time error
        
    }
}

Creating Class Scope with a Class

class Example
{
    void method()
    {
        field = 42; // ok
        
    }
    void anotherMethod()
    {
        field = 42; // ok
        
    }
    int field;
}

Overloading Identifiers

You are allowed to overload a method, but only when the two methods have different parameters; that is, they have the same name but a different number of parameters, or the types of the parameters differ. This capability is allowed so that, when you call a method, you supply comma-separated arguments and the number and type of the arguments is used to select one of the overloaded methods.

The WriteLine method of the Console class is a good example of overloading. If you want to write a string to the console, you pass a string argument to WriteLine, and WriteLine(string s) is automatically called. If you want to write an int to the console, you pass an int argument to WriteLine and WriteLine(int i) is automatically called. Once again, the compiler sorts out the details for you.

At compile time, the compiler looks at the types of the arguments you are passing in and then calls the version of the named method that has a matching set of parameters. Here is an example:

static void Main()
{
    Console.WriteLine("The answer is ");
    Console.WriteLine(42);
}

Whereas you can overload the parameters of a method, you can't overload the return type of a method. In other words, you can't declare two methods with the same name that differ only in their return type. (The compiler is clever, but not that clever.)

Writing and Calling Methods

In the final exercise, you'll use the Visual Studio .NET debugger to run your program in slow motion. You'll see when each method is called (this action is referred to as stepping into the method) and then see each return statement transfer control back to the caller (also known as stepping out of the method).

While you are stepping in and out of methods, you'll use the tools on the Debug toolbar. The Debug toolbar should appear automatically when you debug a program. If the toolbar does not appear, you can display it by pointing to Toolbars on the View menu and then clicking Debug.

Congratulations! You've successfully written and called methods and used the Visual Studio .NET debugger to step in and out of methods as they run.

If you want to continue to the next chapter

• Keep Visual Studio .NET running and turn to Chapter 4.

If you want to exit Visual Studio .NET now

• On the File menu, click Exit. If you see a Save dialog box, click Yes.

Chapter 3 Quick Reference

int addValues(int lhs, int rhs)

{
    
}

return lhs + rhs; 

return;

addValues(39, 3);

Last Updated: March 11, 2003

Top of Page