1. Reference: COS240 Syllabus
COS240 O-O Languages AUBG, COS dept
Lecture 31
Title:
C# Methods
Reference: COS240 Syllabus
5/28/2018
Assoc. Prof. Stoyan Bonev

2. Assoc. Prof. Stoyan Bonev
Lecture Contents:
Structure of a C# program
Accent on methods
Components of a C# program
Methods
Types of parameters
By value and by reference (out, ref)
The params qualifier
Named parameters
Optional parameters
Sample demo programs
5/28/2018
Assoc. Prof. Stoyan Bonev

3. Anatomy of a C# program

4. The Basics of a C# Program
C# program: collection of classes. Classes capsulated as namespaces – named or unnamed
Namespace: collection of related classes
Class: collection of data items and methods
Method: designed to accomplish a specific task
There is a main method in every C# program. static void Main(string[] args)
Main method provides the control of program flow.
Java Programming: From Problem Analysis to Program Design, 4e
Java Programming: From Problem Analysis to Program Design, 3e 4 4

5. C# Elements Figure 1-17 Relationship among C# elements
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 5
Source: Longman dictionary 1987 5

6. Anatomy of a Method Methods defined inside classes
Group program statements
Based on functionality
Called one or more times
All programs consist of at least one method
Main( )
User-defined method
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 6
Source: Longman dictionary 1987 6

7. Required method /* SquareExample.cs Author: Doyle */ using System;
namespace Square {
public class SquareExample
public static void Main( )
int aValue = 768;
int result;
result = aValue * aValue;
Console.WriteLine(“{0} squared is {1}”, aValue, result);
Console.Read( ); }
Required method
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 7
Source: Longman dictionary 1987 7

8. Anatomy of a Method (continued)
Figure 3-1 Method components
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 8
Source: Longman dictionary 1987 8

9. Modifiers Appear in method headings
Appear in the declaration heading for classes and other class members
Indicate how it can be accessed
Types of modifiers
Static
Access
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 9
Source: Longman dictionary 1987 9

10. Static Modifier
Indicates member belongs to the type itself rather than to a specific object of a class
Main( ) must include static in heading
Members of the Math class are static
public static double Pow(double, double)
Methods that use the static modifier are called class methods
Instance methods require an object
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 10
Source: Longman dictionary 1987 10

11. Access Modifiers public protected internal protected internal private
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 11
Source: Longman dictionary 1987 11

12. Level of Accessibility
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 12
Source: Longman dictionary 1987 12

13. Return Type
Indicates what type of value is returned when the method is completed
Always listed immediately before method name
void
No value being returned
return statement
Required for all non-void methods
Compatible value
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 13
Source: Longman dictionary 1987 13

14. Return Type (continued)
public static double CalculateMilesPerGallon
(int milesTraveled, double gallonsUsed) {
return milesTraveled / gallonsUsed; }
Compatible value (double) returned
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 14
Source: Longman dictionary 1987 14

15. Method Names Follow the rules for creating an identifier Examples
Pascal case style
Action verb or prepositional phrase
Examples
CalculateSalesTax( )
AssignSectionNumber( )
DisplayResults( )
InputAge( )
ConvertInputValue( )
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 15
Source: Longman dictionary 1987 15

16. Parameters Supply unique data to method Appear inside parentheses
Include data type and an identifier
In method body, reference values using identifier name
Parameter refers to items appearing in the heading
Argument for items appearing in the call
Formal parameters
Actual arguments
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 16
Source: Longman dictionary 1987 16

17. Parameters (continued)
public static double CalculateMilesPerGallon
(int milesTraveled, double gallonsUsed) {
return milesTraveled / gallonsUsed; }
Call to method inside Main( ) method
Console.WriteLine(“Miles per gallon = {0:N2}”,
CalculateMilesPerGallon(289, 12.2));
Two formal parameters
Actual arguments
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 17
Source: Longman dictionary 1987 17

18. Parameters (continued)
Like return types, parameters are optional
Keyword void not required (inside parentheses) – when there are no parameters
public void DisplayMessage( ) {
Console.Write(”This is “);
Console.Write(”an example of a method ”);
Console.WriteLine(“body. ”);
return; // no value is returned }
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 18
Source: Longman dictionary 1987 18

19. Method Body Enclosed in curly braces
Include statements ending in semicolons
Declare variables
Do arithmetic
Call other methods
Value-returning methods must include return statement
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 19
Source: Longman dictionary 1987 19

20. Calling Class Methods Invoke a method
Call to method that returns no value [qualifier].MethodName(argumentList);
Qualifier
Square brackets indicate optional
Class or object name
Call to method does not include data type
Use IntelliSense
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 20
Source: Longman dictionary 1987 20

21. Predefined Methods Extensive class library Console class
Overloaded methods
Write( )
WriteLine( )
Read( )
Not overloaded
Returns an integer
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 21
Source: Longman dictionary 1987 21

22. Call Read( ) Methods int aNumber;
Console.Write(“Enter a single character: ”);
aNumber = Console.Read( );
Console.WriteLine(“The value of the character entered: ”
+ aNumber);
Enter a single character: a
The value of the character entered: 97
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 22
Source: Longman dictionary 1987 22

23. Call Read( ) Methods (continued)
int aNumber;
Console.WriteLine(“The value of the character entered: “
+ (char) Console.Read( ));
Enter a single character: a
The value of the character entered: a
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 23
Source: Longman dictionary 1987 23

24. Call ReadLine( ) Methods
More versatile than the Read( )
Returns all characters up to the enter key
Not overloaded
Always returns a string
String value must be parsed
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 24
Source: Longman dictionary 1987 24

25. Call Parse( ) Predefined static method
All numeric types have a Parse( ) method
double.Parse("string number")
int.Parse("string number")
char.Parse("string number")
bool.Parse("string number")
Expects string argument
Argument must be a number – string format
Returns the number (or char or bool)
C# Programming: From Problem Analysis to Program Design

26. /* SquareInputValue.cs Author: Doyle */ using System; namespace Square {
class SquareInputValue
static void Main( )
string inputStringValue;
double aValue, result;
Console.Write("Enter a value to be squared: ");
inputStringValue = Console.ReadLine( );
aValue = double.Parse(inputStringValue);
result = Math.Pow(aValue, 2);
Console.WriteLine("{0} squared is {1} ", aValue, result);
Console.ReadKey( );
} } } // Curly braces should be lined up
C# Programming: From Problem Analysis to Program Design

27. Call Parse( ) (continued)
string sValue = " true ";
Console.WriteLine (bool.Parse(sValue)); // displays True
string strValue = "q";
Console.WriteLine(char.Parse(strValue)); // displays q
C# Programming: From Problem Analysis to Program Design

28. Call Parse( ) with Incompatible Value
Console.WriteLine(char.Parse(sValue));
when sValue referenced “True”
Figure 3-6 System.FormatException run-time error
C# Programming: From Problem Analysis to Program Design

29. TryParse() method
The TryParse( ) method will convert a string value sent as an argument to its equivalent numeric value, but it doesn’t throw an exception when the conversion fails.
Java Programming: From Problem Analysis to Program Design, 3e

30. TryParse( ) Method
Parse( ) method and methods in Convert class convert string values sent as arguments to their equivalent numeric value
If the string value being converted is invalid, program crashes as an Exception is thrown. Two ways to avoid the program crash:
Could test the value prior to doing conversion with an if statement
Another option is to use the TryParse( ) method
C# Programming: From Problem Analysis to Program Design

31. TryParse( ) Method public static bool TryParse
(string someStringValue, out int result)
if (int.TryParse(inValue, out v1) = = false)
Console.WriteLine("Did not input a valid integer - " +
"0 stored in v1");
Result stored here, when conversion occurs
String value returned from Console.ReadLine( )
Test…if problem, prints message, does not try to convert
C# Programming: From Problem Analysis to Program Design

32. TryParse( ) Method
Each of the built in data types have a TryParse( ) method
char.TryParse( ), int.TryParse( ), decimal.TryParse( ), etc
If there is a problem with the data, 0 is stored in the out argument and TryParse( ) returns false.
Show LargestValue example
C# Programming: From Problem Analysis to Program Design

33. Convert Class
More than one way to convert from one base type to another
System namespace — Convert class — static methods
Convert.ToDouble( )
Convert.ToDecimal( )
Convert.ToInt32( )
Convert.ToBoolean( )
Convert.ToChar( )
int newValue = Convert.ToInt32(stringValue);
C# Programming: From Problem Analysis to Program Design

34. Predefined methods
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 34

35. C# Programming: From Problem Analysis to Program Design 35
Source: Longman dictionary 1987 35

36. C# Programming: From Problem Analysis to Program Design 36
Source: Longman dictionary 1987 36

37. C# Programming: From Problem Analysis to Program Design 37
Source: Longman dictionary 1987 37

38. Math( ) Class Each call returns a value
double aValue = ;
double result1,
result2;
result1 = Math.Floor(aValue); // result1 = 78
result2 = Math.Sqrt(aValue); // result2 =
Console.Write(“aValue rounded to 2 decimal places”
+ “ is {0}”, Math.Round(aValue, 2));
aValue rounded to 2 decimal places is 78.93
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 38
Source: Longman dictionary 1987 38

39. Method Calls That Return Values
In an assignment statement
Line 1 int aValue = 200;
Line 2 int bValue = 896;
Line 3 int result;
Line 4 result = Math.Max(aValue, bValue); // result = 896
Line 5 result += bValue *
Line Math.Max(aValue, bValue) – aValue;
// result = (896 * ) (result = )
Line 7 Console.WriteLine(“Largest value between {0} ”
Line “and {1} is {2}”, aValue, bValue,
Line Math.Max(aValue, bValue));
Part of arithmetic expression
Argument to another method call
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 39
Source: Longman dictionary 1987 39

40. Writing Your Own Class Methods
[modifier(s)] returnType  MethodName ( parameterList ) { 
// body of method - consisting of executable statements    }
void Methods
Simplest to write
No return statement
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 40
Source: Longman dictionary 1987 40

41. Writing Your Own Class Methods – void Types
A call to this method looks like:
DisplayInstructions( );
public static void DisplayInstructions( ) {
Console.WriteLine(“This program will determine how ”
+ “much carpet to purchase.”);
Console.WriteLine( );
Console.WriteLine(“You will be asked to enter the ”
+ “ size of the room and ”);
Console.WriteLine(“the price of the carpet, ”
+ ”in price per square yards.”); }
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 41
Source: Longman dictionary 1987 41

42. Writing Your Own Class Methods – void Types (continued)
public static void DisplayResults(double squareYards,
double pricePerSquareYard) {
Console.Write(“Total Square Yards needed: ”);
Console.WriteLine(“{0:N2}”, squareYards);
Console.Write(“Total Cost at {0:C} “, pricePerSquareYard);
Console.WriteLine(“ per Square Yard: {0:C}”,
(squareYards * pricePerSquareYard)); }
static method called from within the class where it resides
To invoke method – DisplayResults(16.5, 18.95);
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 42
Source: Longman dictionary 1987 42

43. Value-Returning Method
Has a return type other than void
Must have a return statement
Compatible value
Zero, one, or more data items may be passed as arguments
Calls can be placed:
In assignment statements
In output statements
In arithmetic expressions
Or anywhere a value can be used
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 43
Source: Longman dictionary 1987 43

44. Value-Returning Method (continued)
public static double GetLength( ) {
string inputValue;
int feet, inches;
Console.Write(“Enter the Length in feet: ”);
inputValue = Console.ReadLine( );
feet = int.Parse(inputValue);
Console.Write(“Enter the Length in inches: “);
inches = int.Parse(inputValue);
return (feet + (double) inches / 12); }
Return type→ double
double returned
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 44
Source: Longman dictionary 1987 44

45. Types of Parameters C# offers both
Call by value parameters (default type)
Call by reference parameters
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 45
Source: Longman dictionary 1987 45

46. Assoc. Prof. Stoyan Bonev
Variables can hold either value types or reference types
Value type
where a variable X contains a value type, it directly contains an entity with some value. No other variable Y can directly contain the object contained by X (although Y might contain an entity with the same value).
Reference type
where a variable X contains a reference type, what it directly contains is something that refers to an object. Another variable Y can contain a reference to the same object referred to by X.
Reference types actually hold the value of a memory address occupied by the object they reference.
5/28/2018
Assoc. Prof. Stoyan Bonev 46

47. Assoc. Prof. Stoyan Bonev
5/28/2018
Assoc. Prof. Stoyan Bonev 47

48. Types of Parameters Call by value Other types of parameters
Copy of the original value is made
Other types of parameters
ref
out
params
ref and out cause a method to refer to the same variable that was passed into the method. Useful when there is need to return more than one value
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 48
Source: Longman dictionary 1987 48

49. Types of Parameters
When you use ref/out, call by reference is assumed.
You must include ref/out both in the call (actual argument) and in the method heading (formal parameter). They must match.
The ref keyword cannot be used unless the original argument is initialized before it is sent to the method.
This restriction does not exist for out.
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 49
Source: Longman dictionary 1987 49

50. Types of Parameters Demo program Methods1.cs
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 50
Source: Longman dictionary 1987 50

51. Types of Parameters Demo program parameters.cs
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 51
Source: Longman dictionary 1987 51

52. Types of Parameters (continued)
Figure 3-9 Call by reference versus value
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 52
Source: Longman dictionary 1987 52

53. Types of Parameters Call by value Other types of parameters
Copy of the original value is made
Other types of parameters
ref
out
params
ref and out cause a method to refer to the same variable that was passed into the method
C# Programming: From Problem Analysis to Program Design

54. Upon return from TestDefault
Parameters Example
// Code pulled from Parameters.cs solutions int testValue = 1; TestDefault(testValue); Console.WriteLine("Upon return from TestDefault " + "Value: {0}", testValue); Console.WriteLine( ); public static void TestDefault(int aValue) { aValue = 111; Console.WriteLine("In TestDefault - Value: {0}", aValue); }
Upon return from TestDefault
Value: 1
C# Programming: From Problem Analysis to Program Design

55. Parameters Example (continued)
// Code pulled from Parameters.cs solutions int testValue = 1; TestRef(ref testValue); Console.WriteLine("Upon return from TestRef " + "Value: {0}", testValue); Console.WriteLine( ); public static void TestRef (ref int aValue) { aValue = 333; Console.WriteLine("In TestRef - Value: {0}", aValue); }
Upon return from TestRef
Value: 333
C# Programming: From Problem Analysis to Program Design

56. Parameters Example (continued)
// Code pulled from Parameters.cs solutions int testValue2; TestOut(out testValue2); Console.WriteLine("Upon return from TestOut " + "Value: {0}", testValue2); Console.WriteLine( ); public static void TestOut (out int aValue) { aValue = 222; Console.WriteLine("In TestOut - Value: {0}", aValue); }
Upon return from TestOut
Value: 222
C# Programming: From Problem Analysis to Program Design

57. Parameters.cs Figure 3-8 Output from ParameterClass example
C# Programming: From Problem Analysis to Program Design

58. Types of Parameters (continued)
Figure 3-9 Call by reference versus value
C# Programming: From Problem Analysis to Program Design

59. Testing Parameters App
Comment/uncomment sections while testing
Figure Visual Studio comment out icon
C# Programming: From Problem Analysis to Program Design

60. Demo Programs and Exercises
Java Programming: From Problem Analysis to Program Design, 3e

61. Demo Programs and Exercises
Write a method with two integer parameters and no return value which swaps/exchanges/ the values of its parameters.
Test the method with value parameters
Test the method with ref parameters
Test the method with out parameters
Java Programming: From Problem Analysis to Program Design, 3e

62. Demo Programs
// PP parameter passing mechanisms - swap by value public static void swapByVal(int pa, int pb) { int temp; temp = pa; pa = pb; pb = temp; } //=================================== // Test PP parameter passing mechanisms by value int a, b; a = 20; b = 50; Console.WriteLine("Before swapByVal a={0}, b={1}", a, b); swapByVal(a, b); Console.WriteLine(" After swapByVal a={0}, b={1}", a, b);
Java Programming: From Problem Analysis to Program Design, 3e

63. Demo Programs
// PP parameter passing mechanisms - swap by ref public static void swapByRef1(ref int pa, ref int pb) { int temp; temp = pa; pa = pb; pb = temp; } //============================================ // Test PP parameter passing mechanisms by ref int a, b; a = 70; b = 90; Console.WriteLine("Before swapByRef1 a={0}, b={1}", a, b); swapByRef1(ref a, ref b); Console.WriteLine(" After swapByRef1 a={0}, b={1}", a, b);
Java Programming: From Problem Analysis to Program Design, 3e

64. Demo Programs
// PP parameter passing mechanisms - swap by out public static void swapByRef2(out int pa, out int pb) { pa = 230; pb = 250; } //================================ // Test PP parameter passing mechanisms by out int c, d; // both vars not initialized Console.WriteLine("Before swapByRef2 c={0}, d={1}", c, d); swapByRef2(out c, out d); Console.WriteLine(" After swapByRef2 c={0}, d={1}", c, d);
Java Programming: From Problem Analysis to Program Design, 3e

65. Params Parameter Keyword params used
Appears in formal parameter list (heading to the method)
Must be last parameter listed in the method heading
Indicates number of arguments to the method that may vary
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 65
Source: Longman dictionary 1987 65

66. Params Parameters
When a method uses the params modifier, the parameter is considered a parameter array. It is used to indicate that the number of arguments to the method may vary.
The params argument appears in method heading only. It is prefix of a formal parameter – array identifier and must be the last parameter listed.
That formal parameter cannot be defined as ref or as out parameter.
Demo program VaryingArguments.cs
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 66

67. Types of Parameters Demo program VaryingArguments.cs
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 67
Source: Longman dictionary 1987 67

68. Params Parameters
using System; namespace VaryingArguments { class VaryingArguments public static void Main() DisplayItems(1, 2, 3, 5); int[] anArray = new int[5] {100, 200, 300, 400, 500}; DisplayItems(anArray); DisplayItems(1500, anArray[1] * anArray [2]); } public static void DisplayItems(params int[] item) for ( int i = 0 ; i < item.Length ; i++ ) { Console.Write(item[i] + "\t"); } Console.WriteLine(); } // end of class } // end of namespace
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 68

69. Params Parameters Demo program VaryingArguments.cs
A method may be called with a single value.
Another call to the same method may send 4, or 10, or 100 values, or an array of values
A variable number of arguments are accepted when params argument is included.
Makes method very flexible.
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 69

70. Evolution of the routine concept applied to C# methods
Demo Programs
Evolution of the routine concept applied to C# methods

71. Method Evolution Overloaded methods
Java Programming: From Problem Analysis to Program Design, 3e

72. Method Evolution
public static void displaystr() { for(int i=1; i<=1; i++) { Console.WriteLine("Bulgaria"); } Console.WriteLine("\n"); }
Java Programming: From Problem Analysis to Program Design, 3e

73. Method Evolution
public static void displaystr(int pn) { for(int i=1; i<=pn; i++) { Console.WriteLine("Bulgaria"); } Console.WriteLine("\n"); }
Java Programming: From Problem Analysis to Program Design, 3e

74. Method Evolution
public static void displaystr(String ps) { for(int i=1; i<=1; i++) { Console.WriteLine(ps); } Console.WriteLine("\n"); }
Java Programming: From Problem Analysis to Program Design, 3e

75. Method Evolution
public static void displaystr(String ps, int pn) { for(int i=1; i<=pn; i++) { Console.WriteLine(ps); } Console.WriteLine("\n"); }
Java Programming: From Problem Analysis to Program Design, 3e

76. Method Evolution
public static void displaystr() { for(int i=1; i<=1; i++) { Console.WriteLine("Bulgaria"); } } //======================================================== public static void displaystr(String ps) for(int i=1; i<=1; i++) { Console.WriteLine(ps); } public static void displaystr(int pn) for(int i=1; i<=pn; i++) { Console.WriteLine("Bulgaria"); } public static void displaystr(String ps, int pn) for(int i=1; i<=pn; i++) { Console.WriteLine(ps); }
Java Programming: From Problem Analysis to Program Design, 3e

77. Method Evolution Overloaded methods // Test PP overloaded methods
displaystr();
displaystr("Germany");
displaystr(2);
displaystr("United Kingdom", 4);
Java Programming: From Problem Analysis to Program Design, 3e

78. Method Evolution Default arguments methods
Java Programming: From Problem Analysis to Program Design, 3e

79. Method Evolution Default arguments methods //
// PP default arguments methods
public static double
aveVal(int pa=10, int pb=20, int pc=30, int pd=40) {
return ( pa + pb + pc + pd ) / 4.0; }
Java Programming: From Problem Analysis to Program Design, 3e

80. Method Evolution Default arguments methods //
// Test PP default arguments functions
Console.WriteLine("\n {0}", aveVal());
Console.WriteLine("\n {0}", aveVal(100));
Console.WriteLine("\n {0}", aveVal(100, 200));
Console.WriteLine("\n {0}", aveVal(100, 200, 300));
Console.WriteLine("\n {0}", aveVal(100, 200, 300, 400));
Java Programming: From Problem Analysis to Program Design, 3e

81. Optional Parameters May assign default values to parameters
When you assign a default value to a parameter, it then becomes an optional parameter
public static void DoSomething(string name, int age = 21,
bool currentStudent = true, string major = "CS")
Can now call DoSomething( ) and send in arguments for the default value or the default values will be assigned to the parameters
C# Programming: From Problem Analysis to Program Design

82. Method Evolution Named parameters
Java Programming: From Problem Analysis to Program Design, 3e

83. Named Parameters
Named arguments free you from the need to remember or to look up the order of parameters for the method call
DoSomething (name: “Robert Wiser", age: 20);
DoSomething (name: "Paul Nelson", major: “IS");
DoSomething (name: “Fred Terrell", age: 25, major: “BUS");
C# Programming: From Problem Analysis to Program Design

84. Method Evolution An artefact with C# methods
Java Programming: From Problem Analysis to Program Design, 3e

85. Method Evolution An artefact with C# methods Given a method
int add(int pa, int pb) {
return pa + pb; }
Java Programming: From Problem Analysis to Program Design, 3e

86. Method Evolution An artefact with C# methods
Are the call statements valid?
int a = 20, b = 50;
int x = add(5, 6);
int y = add(a, b);;
Int z = add(a + 5 * 6, b – 7 * 8);
Int t = add(a = 5 * 6, b = 7 * 8);
Java Programming: From Problem Analysis to Program Design, 3e

87. Practical session
Expand the program Methods1.cs adding more methods that reside in the same class with method Main():
Iterative GCD – gcdi()
Iterative/Recursive factorial – facti(), factr()
Iterative/Recursive Fibonacci – fiboi(), fibor()
Iterative/Recursive Sum(1..n) – sumi(), sumr()
Iterative/Recursive Power operator simulator – powi(), powr()
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 87

88. Practical session
Expand the program Parameters.cs adding more methods that reside in the same class with method Main():
Method void swap(int pa, int pb) that exchanges the values of its parameters/arguments
Test the swap method with:
Input parameters by value
Output ref parameters
Output out parameters
C# Programming: From Problem Analysis to Program Design
C# Programming: From Problem Analysis to Program Design 88

89. Thank You for Your attention!