Chapter Three

Using Methods
1
2
Objectives

– Learn how to write methods with no arguments and no

return value
– Learn about implementation hiding and how to use multiple
files
– Learn how to write methods that require a single argument
– Learn how to write methods that require multiple arguments
– Learn how to write methods that return a value
 Objective
3

– Learn how to use reference and output parameters with

methods
– Learn how to overload methods
– Learn how to avoid ambiguous methods
 Writing Methods with No Arguments and No
Return Value
4

– A method is a series of statements that carry out a task

– A method can be invoked or called by other methods
– Method names are always followed by a set of parentheses
– Programmers can create custom methods
– Example:
Console.WriteLine(“HELLO WORLD”);
 Writing Methods with No Arguments and No
Return Value
5

– In C#, a method must include:

– A method declaration
– An opening curly brace
– A method body
– A closing brace
 Writing Methods with No Arguments and No
Return Value
6

– The optional access modifiers for a method include: public,

protected internal, protected, and private
– If an access modifier for a method is not declared, the method
becomes private by default
– The static keyword indicates that a method can be called without
referring to an object
– Every method has a return type
 Writing Methods with No Arguments and No
Return Value
7

 This is an example of a method calling another method

 Hiding Implementation by Using Multiple
Files
8

– An important principle of object-oriented programming is the

notion of implementation hiding
– The users of methods should only be aware of the interface
– The following implementation, with two newline escape
sequences, could have been used instead of the previous code—
neither implementation effects the user
 Hiding Implementation by Using Multiple
Files
9

– Two different implementations of the WelcomeMessage()

method
 Hiding Implementation by Using Multiple
Files
10

– A multifile assembly is a program that is composed of many different

files and classes
– A netmodule file is a file that contains modules to be used as part of
another program
– Compiling multifile assemblies and netmodules requires a slightly
different command
csc /t:module LogoNamespace.cs
csc DemoLogo2.cs /addmodule:LogoNameSpace.netmodule
 Writing Methods That Require a Single
Argument
11

– Arguments or parameters are used to communicate and send

additional information to methods
– The following items are included in the method declaration
parentheses when declaring a method that can receive an argument:
– The type of the argument
– A local name for the argument
 Writing Methods That Require a Single
Argument
12

– The identifier saleAmount is simply the name the value “goes

by” while it is used in the method, regardless of the name the
value “goes by” in the calling program
 Writing Methods That Require a Single
Argument
13

– A formal parameter is a parameter in the method declaration

– An actual parameter refers to an argument within a method call
 Writing Methods That Require a Single
Argument
14

– Complete program using the ComputeSevenPercentSalesTax()

method
 Writing Methods That Require a Single
Argument
15

– Output of UseSevenPercentSalesTax program

 Writing Methods That Require Multiple
Arguments
16

– You can pass multiple arguments to a method by listing the

arguments within the call to the method and separating them
with commas
– You can write a method to take any number of arguments in
any order
 Writing Methods That Return Values
17

– The return type for a method can be any type used in the C#
programming language
– A method can also return nothing, in which case the return type is
void
– A method’s return type is also known as a method’s type
 Writing Methods That Return Values
18

– The return type in the above example is double

– The return statement causes the value stored in gross to be
sent back to any method that calls the CalcPay() method
 Writing Methods That Return Values
19

– Program using the CalcPay() method

 Using ref and out Parameters Within
Methods
20

– In C#, you can write methods with four kinds of formal

parameters listed within the parentheses in the method
header
– Value parameters
– Reference parameters
– Output parameters
– Parameter arrays
 Using ref and out Parameters Within
Methods
21

– When you use a value parameter in a method header, you

indicate the parameter’s type and name, and the method
receives a copy of the value passed to it
 Using ref and out Parameters Within
Methods
22

– Both the reference and output parameters have memory addresses

that are passed to a method, allowing it to alter the original variables
– When you use a reference parameter to a method, the parameter
must be assigned a value before you use it in the method call
– When you use an output parameter, it does not contain an original
value
 Using ref and out Parameters Within
Methods
23

– Both reference and output parameters act as aliases, or other names,

for the same memory location
– The keyword ref is used to indicate a reference parameter
– The keyword out is used to indicate an output parameter
 Using ref and out Parameters Within
Methods
24

– Program calling method with a reference parameter

 Using ref and out Parameters Within
Methods
25

– In the preceding code:

– The modifier ref precedes the variable in both the method call
and the method header
– The passed and received variables occupy the same memory
location
– The passed variable was assigned a value
 Using ref and out Parameters Within
Methods
26

– Unlike the reference parameter, the output parameter does not

need a value assigned to it (before it is used in a method call)
– The output parameter is convenient when the passed variable
doesn’t have a value yet
– The output parameter gets its value from the method, and these
values persist back to the calling program
 Overloading Methods
27

– Overloading involves using one term to indicate diverse meanings

– When you overload a C# method, you write multiple methods with
a shared name
– The compiler understands the meaning based on the arguments
you use with the method
 Avoiding Ambiguous Methods
28

– By overloading methods, you run the risk of creating an

ambiguous situation
– An ambiguous situation is one in which the compiler cannot
determine which method to use
– The compiler usually distinguishes between overloaded methods
by the argument lists, but this is NOT always possible
 Avoiding Ambiguous Methods
29

– If only one method exists, there is no chance of an ambiguous situation

– This code would work fine even if your arguments were both of type int
 Avoiding Ambiguous Methods
30

– What happens when another version of the same method is added?

– An ambiguous situation does not exist because the compiler can determine
the appropriate method
 Avoiding Ambiguous Methods
31

– A more complicated and potentially ambiguous situation

arises when the compiler cannot determine which of several
versions of a method to use
 Avoiding Ambiguous Methods
32

– An ambiguous situation arises because there is no exact match for the

method call
– An overloaded method is not ambiguous on its own—it become
ambiguous only if you create an ambiguous situation
 Chapter Summary
33

– A method is a series of reusable statements that carry out a task

– Invoking programs must know the interface to methods but need not
understand the hidden implementation
– Methods receive data in the form of parameters or arguments
– You can pass multiple arguments to a method by listing the arguments
within the call to the method and separating them with commas
 Chapter Summary
34

– The return type for a method can be any type in the C# programming
language
– In C#, you can write methods with four kinds of formal parameters
listed within the parentheses in the method header
– Overloading a method involves writing multiple methods with the
same name, but with different arguments
– The compiler determines which of several versions of a method to call
based on argument lists