Mastering C# Methods: Writing, Implementing, and Overloading

1. Chapter Three Using Methods

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

3. Objective • Learn how to use reference and output parameters with methods • Learn how to overload methods • Learn how to avoid ambiguous methods

4. Writing Methods with No Arguments and No Return Value • 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”);

5. Writing Methods with No Arguments and No Return Value • In C#, a method must include: • A method declaration • An opening curly brace • A method body • A closing brace

6. Writing Methods with No Arguments and No Return Value • The optional access modifiers for a method include: public, protectedinternal, protected, internal, 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

7. Writing Methods with No Arguments and No Return Value • This is an example of a method calling another method

8. Hiding Implementation by Using Multiple Files • 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

9. Hiding Implementation by Using Multiple Files • Two different implementations of the WelcomeMessage() method

10. Hiding Implementation by Using Multiple Files • 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

11. Writing Methods That Require a Single Argument • 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

12. Writing Methods That Require a Single Argument • 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

13. Writing Methods That Require a Single Argument • A formal parameter is a parameter in the method declaration • An actual parameter refers to an argument within a method call

14. Writing Methods That Require a Single Argument • Complete program using the ComputeSevenPercentSalesTax() method

15. Writing Methods That Require a Single Argument • Output of UseSevenPercentSalesTax program

16. Writing Methods That Require Multiple Arguments • 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

17. Writing Methods That Return Values • 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

18. Writing Methods That Return Values • 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

19. Writing Methods That Return Values • Program using the CalcPay() method

20. Using ref and out Parameters Within Methods • 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

21. Using ref and out Parameters Within Methods • 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

22. Using ref and out Parameters Within Methods • 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

23. Using ref and out Parameters Within Methods • 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

24. Using ref and out Parameters Within Methods • Program calling method with a reference parameter

25. Using ref and out Parameters Within Methods • 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

26. Using ref and out Parameters Within Methods • 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

27. Overloading Methods • 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

28. Avoiding Ambiguous Methods • 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

29. Avoiding Ambiguous Methods • 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

30. Avoiding Ambiguous Methods • 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

31. Avoiding Ambiguous Methods • A more complicated and potentially ambiguous situation arises when the compiler cannot determine which of several versions of a method to use

32. Avoiding Ambiguous Methods • 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

33. Chapter Summary • 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

34. Chapter Summary • 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