borb
2 weeks ago
parent
515fc40d32
commit
36809c09b3
File diff suppressed because one or more lines are too long
@ -1,270 +1,320 @@
|
|||||||
# Methods
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
marp: true
|
||||||
# Overview
|
paginate: true
|
||||||
|
math: mathjax
|
||||||
Functions
|
theme: buutti
|
||||||
|
title: 6. Methods
|
||||||
Methods
|
---
|
||||||
|
|
||||||
Parameters
|
|
||||||
|
|
||||||
Return Values
|
|
||||||
|
|
||||||
Scope of Methods
|
|
||||||
|
|
||||||
# What is a function?
|
|
||||||
|
|
||||||
* Functions are self contained modules of code that accomplish a specific task.
|
|
||||||
* Function is basically a block of code that can be executed over and over again in the program
|
|
||||||
* Instead of writing the same code over and over again to the program, it can be written only once as a function
|
|
||||||
* Functions can get data, _parameters_ , from the _caller_
|
|
||||||
* Functions can return data, _return value_ , to the caller
|
|
||||||
* Defining parameters and return values are optional, not all functions have both and some have neither!
|
|
||||||
|
|
||||||
# Function execution
|
|
||||||
|
|
||||||
* When a function is called the program leaves the current section of the code and begins to execute the first line of code inside the function.
|
|
||||||
* The program execution comes to the line of code where the function call is
|
|
||||||
* The program enters the function
|
|
||||||
* Instructions inside the function are executed from top to bottom
|
|
||||||
* Remember scopes: The variables defined inside the function are not visible outside the function!
|
|
||||||
* The program leaves the function and returns to the point where the function call was and continues the execution
|
|
||||||
* If function returned any data, it can be used where the function was called
|
|
||||||
|
|
||||||
# Methods
|
# Methods
|
||||||
|
|
||||||
In C#, __methods __ are functions which are inside of a class
|
<!-- headingDivider: 5 -->
|
||||||
|
<!-- class: invert -->
|
||||||
Since the main function is inside of a class, all functions in C# are actually just called methods
|
|
||||||
|
## Overview
|
||||||
* A methods are executed only when it is __called__
|
|
||||||
* For example, Console.WriteLine() is a method which contains more complex code to print stuff on to the console
|
* Functions
|
||||||
* Instead of writing all that complex stuff at every printout, you can just use the short method call Console.WriteLine()
|
* Methods
|
||||||
|
* Parameters
|
||||||
|
* Return values
|
||||||
|
* Scope of methods
|
||||||
|
|
||||||
|
## What is a function?
|
||||||
|
|
||||||
|
* Functions are self-contained modules of code that accomplish a specific task
|
||||||
|
* Basically, a named block of code that can be executed as many times as we want
|
||||||
|
* Instead of writing the same code over and over again, do it only once as a function, and ***call*** it many times
|
||||||
|
```csharp
|
||||||
|
void Example()
|
||||||
|
{
|
||||||
|
Console.WriteLine("Hello World");
|
||||||
|
}
|
||||||
|
|
||||||
|
Example(); // calling the function three times
|
||||||
|
Example();
|
||||||
|
Example();
|
||||||
|
```
|
||||||
|
|
||||||
|
### Parameters and returns
|
||||||
|
|
||||||
|
* Functions can acquire data, a.k.a. **_parameters_**, from the **_caller_**
|
||||||
|
* Functions can return data, a.k.a. its **_return value_**, to the caller
|
||||||
|
* Defining parameters and return values are optional — not all functions have both, and some have neither!
|
||||||
|
* Here's a function that takes in one parameter and returns nothing (hence, `void`)
|
||||||
|
```csharp
|
||||||
|
void PrintName(string param)
|
||||||
|
{
|
||||||
|
Console.WriteLine("My name is " + param);
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
## Function execution
|
||||||
|
|
||||||
|
When a function is called, the program leaves the current section of the code and begins to execute the first line of code inside the function.
|
||||||
|
1) The program execution comes to the line of code where the function call is
|
||||||
|
2) The program enters the function
|
||||||
|
3) Instructions inside the function are executed from top to bottom
|
||||||
|
* Remember scopes: The variables defined inside the function are not visible outside the function!
|
||||||
|
4) The program leaves the function and returns to the point where the function call was and continues the execution
|
||||||
|
5) If the function returned any data, it can be used where the function was called
|
||||||
|
|
||||||
|
### Methods vs functions
|
||||||
|
|
||||||
|
* In C#, most functions we see are *__methods__*: functions that are inside a ***class***
|
||||||
|
* Even the main function is inside a class in C#, so it is a method
|
||||||
|
* Classes are explained in [Lecture 7](7-classes-and-objects)
|
||||||
|
* Here's the earlier function as a method inside the `Program` class
|
||||||
|
```csharp
|
||||||
|
class Program
|
||||||
|
{
|
||||||
|
void PrintName(string param)
|
||||||
|
{
|
||||||
|
Console.WriteLine("My name is " + param);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
### Calling methods
|
||||||
|
|
||||||
|
* A method is executed only when it is *__called__*
|
||||||
|
* Some methods are already predefined, so we can call them right away
|
||||||
|
* For example, `Console.WriteLine()` is a method that contains code that prints stuff in the console
|
||||||
|
* Instead of writing ourselves all that complex stuff the method contains, we just use the short method call `Console.WriteLine()`
|
||||||
* The use of methods reduces repetitive code, adds modularity and makes designing your programs easier
|
* The use of methods reduces repetitive code, adds modularity and makes designing your programs easier
|
||||||
|
|
||||||
# Methods - Example
|
### Methods: An example
|
||||||
|
|
||||||
|
<div class='columns21' markdown='1'>
|
||||||
|
<div markdown='1'>
|
||||||
|
|
||||||
|
```csharp
|
||||||
class Program
|
class Program
|
||||||
|
|
||||||
{
|
|
||||||
|
|
||||||
static void Main(string[] args)
|
|
||||||
|
|
||||||
{
|
|
||||||
|
|
||||||
void PrintBlock()
|
|
||||||
|
|
||||||
{
|
|
||||||
|
|
||||||
Console.WriteLine("---------------------");
|
|
||||||
|
|
||||||
Console.WriteLine("| This is cool but |");
|
|
||||||
|
|
||||||
Console.WriteLine("| you wouldn't want |");
|
|
||||||
|
|
||||||
Console.WriteLine("| to write this |");
|
|
||||||
|
|
||||||
Console.WriteLine("| block of code |");
|
|
||||||
|
|
||||||
Console.WriteLine("| every time! |");
|
|
||||||
|
|
||||||
Console.WriteLine("---------------------");
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
PrintBlock();
|
|
||||||
|
|
||||||
PrintBlock();
|
|
||||||
|
|
||||||
PrintBlock();
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
* In this example, we declared a new method called PrintBlock
|
|
||||||
* Finally the method was called three times
|
|
||||||
* Each time the entire code inside the method was executed
|
|
||||||
* The void statement means that the method does not return anything
|
|
||||||
* More on that later
|
|
||||||
|
|
||||||
# Parameters
|
|
||||||
|
|
||||||
Sometimes you want to pass data into the method when calling it
|
|
||||||
|
|
||||||
This is done by adding __parameters __ to the method declaration, inside the brackets:
|
|
||||||
|
|
||||||
void PrintSum(int val1, int val2)
|
|
||||||
|
|
||||||
{
|
{
|
||||||
|
void PrintBlock()
|
||||||
int sum = val1 + val2;
|
{
|
||||||
|
Console.WriteLine("---------------------");
|
||||||
Console.WriteLine("Sum of " + val1 + " and " + val2 + " is " + sum);
|
Console.WriteLine("| This is cool but |");
|
||||||
|
Console.WriteLine("| you wouldn't want |");
|
||||||
|
Console.WriteLine("| to write this |");
|
||||||
|
Console.WriteLine("| block of code |");
|
||||||
|
Console.WriteLine("| every time! |");
|
||||||
|
Console.WriteLine("---------------------");
|
||||||
|
}
|
||||||
|
|
||||||
|
static void Main(string[] args)
|
||||||
|
{
|
||||||
|
PrintBlock();
|
||||||
|
PrintBlock();
|
||||||
|
PrintBlock();
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
```
|
||||||
|
|
||||||
The values to be passed are set as __arguments __ in the method call, inside the brackets:
|
</div>
|
||||||
|
<div markdown='1'>
|
||||||
|
|
||||||
PrintSum(2, 5); // Outputs "Sum of 2 and 5 is 7
|
|
||||||
|
|
||||||
PrintSum(5, 5); // Outputs "Sum of 5 and 5 is 10
|
|
||||||
|
|
||||||
# Parameters - Example
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
* In the previous example, we declared a new method called `PrintBlock`
|
||||||
|
* Then, the method was called three times
|
||||||
|
* Each time the entire code inside the method was executed
|
||||||
|
* Why didn't we have to use the class name the method belonged to, unlike with `Console.WriteLine`?
|
||||||
|
* Short answer: Because we called the method inside the class
|
||||||
|
* The `void` statement means that the method does not return anything
|
||||||
|
* More on that later!
|
||||||
|
|
||||||
|
## Parameters
|
||||||
|
|
||||||
|
* Sometimes you want to pass data into the method when calling it
|
||||||
|
* This is done by adding *__parameters__* to the method declaration inside the parentheses:
|
||||||
|
```csharp
|
||||||
|
void PrintSum(int val1, int val2)
|
||||||
|
{
|
||||||
|
int sum = val1 + val2;
|
||||||
|
Console.WriteLine("Sum of " + val1 + " and " + val2 + " is " + sum);
|
||||||
|
}
|
||||||
|
```
|
||||||
|
* The values to be passed are set as ***arguments*** in the method call inside the parentheses:
|
||||||
|
```csharp
|
||||||
|
PrintSum(2, 5); // Outputs "Sum of 2 and 5 is 7
|
||||||
|
PrintSum(5, 5); // Outputs "Sum of 5 and 5 is 10
|
||||||
|
```
|
||||||
|
|
||||||
|
### Parameters: An example
|
||||||
|
|
||||||
|
<div class='columns21' markdown='1'>
|
||||||
|
<div markdown='1'>
|
||||||
|
|
||||||
|
```csharp
|
||||||
static void Main(string[] args)
|
static void Main(string[] args)
|
||||||
|
|
||||||
{
|
|
||||||
|
|
||||||
int centuriesPrinted = 0;
|
|
||||||
|
|
||||||
void PrintCentury(int century)
|
|
||||||
|
|
||||||
{
|
|
||||||
|
|
||||||
centuriesPrinted++;
|
|
||||||
|
|
||||||
Console.WriteLine("Current century: " + century);
|
|
||||||
|
|
||||||
Console.WriteLine("Total centuries printed: " + centuriesPrinted);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
for (int i = 0; i < 500; i += 100)
|
|
||||||
|
|
||||||
{
|
|
||||||
|
|
||||||
PrintCentury(i);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
# Optional Parameters
|
|
||||||
|
|
||||||
You can give a parameter a default value by assigning it in the method declaration
|
|
||||||
|
|
||||||
This makes the parameter optional
|
|
||||||
|
|
||||||
double CircleArea(double radius = 0)
|
|
||||||
|
|
||||||
{
|
|
||||||
|
|
||||||
double area = Math.PI * radius * radius;
|
|
||||||
|
|
||||||
return area;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
Console.WriteLine(CircleArea()); // This outputs 0
|
|
||||||
|
|
||||||
Console.WriteLine(CircleArea(2)); // This outputs 12,56637...
|
|
||||||
|
|
||||||
# Exercise 1
|
|
||||||
|
|
||||||
Write two methods Sum and Difference, which both have two parameters of type int, named value1 and value2. Sum should print "The sum of __*value1*__ and __*value2*__ is __*sum*__ ", and Difference should print "The difference of __*value1*__ and __*value2*__ is __*difference*__ .
|
|
||||||
|
|
||||||
Call the methods from the main method multiple times with different values.
|
|
||||||
|
|
||||||
# Return Values
|
|
||||||
|
|
||||||
The return value of a method is __returned __ with the return keyword:
|
|
||||||
|
|
||||||
double radius = 2;
|
|
||||||
|
|
||||||
Console.WriteLine(CircleArea(radius)); // Outputs 12,56637...
|
|
||||||
|
|
||||||
double CircleArea(double radius)
|
|
||||||
|
|
||||||
{
|
|
||||||
|
|
||||||
double area = Math.PI * radius * radius;
|
|
||||||
|
|
||||||
return area;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
In the first examples, the method declarations started with the void expression, which means that the method doesn't return anything
|
|
||||||
|
|
||||||
Here the method was declared as type double, which means that the method has to return a variable of type double
|
|
||||||
|
|
||||||
# Multiple Return Values
|
|
||||||
|
|
||||||
It is possible to return multiple values in the form of a __tuple__ :
|
|
||||||
|
|
||||||
(string, string) FirstAndLastName(string fullname)
|
|
||||||
|
|
||||||
{
|
{
|
||||||
|
int centuriesPrinted = 0;
|
||||||
string[] names = fullname.Split(' ');
|
|
||||||
|
void PrintCentury(int century)
|
||||||
return (names[0], names[names.Length - 1]);
|
{
|
||||||
|
centuriesPrinted++;
|
||||||
|
Console.WriteLine
|
||||||
|
("Current century: " + century);
|
||||||
|
Console.WriteLine
|
||||||
|
("Total centuries printed: " + centuriesPrinted);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (int i = 0; i < 500; i += 100)
|
||||||
|
{
|
||||||
|
PrintCentury(i);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
```
|
||||||
|
|
||||||
(string first, string last) = FirstAndLastName("Hans \\"Dolph\\" Lundgren");
|
</div>
|
||||||
|
<div markdown='1'>
|
||||||
Console.WriteLine($"First name: {first}, last name: {last}");
|
|
||||||
|
|
||||||
// Outputs "First name: Hans, last name: Lundgren"
|
|
||||||
|
|
||||||
If only one value from a tuple is needed, you can use a __discard __ (\_)
|
|
||||||
|
|
||||||
// Only last name is allocated to a variable
|
|
||||||
|
|
||||||
(\_, string lastName) = FirstAndLastName("Arnold Alois Schwarzenegger");
|
|
||||||
|
|
||||||
# Scope of Methods
|
|
||||||
|
|
||||||
The variables declared inside of a method are __local variables__ and only accessible inside of that method
|
|
||||||
|
|
||||||
void ScopeExample()
|
Note that this method modifies a value that is ***outside*** the method, which is considered bad practice.
|
||||||
|
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
## Optional parameters
|
||||||
|
|
||||||
|
* You can give a parameter a default value by assigning it in the method declaration
|
||||||
|
* This makes the parameter optional
|
||||||
|
```csharp
|
||||||
|
double CircleArea(double radius = 0)
|
||||||
|
{
|
||||||
|
double area = Math.PI * radius * radius;
|
||||||
|
return area;
|
||||||
|
}
|
||||||
|
Console.WriteLine(CircleArea()); // This outputs 0
|
||||||
|
Console.WriteLine(CircleArea(2)); // This outputs 12,56637...
|
||||||
|
```
|
||||||
|
|
||||||
|
## Exercise 1
|
||||||
|
<!--_class: "exercise invert" -->
|
||||||
|
|
||||||
|
1) Write two methods `Sum` and `Difference` that both take in two parameters of type `int`, `value1` and `value2`.
|
||||||
|
* `Sum` should print `The sum of <value1> and <value2> is <sum>`
|
||||||
|
* `Difference` should print `The difference of <value1> and <value2> is <difference>`
|
||||||
|
2) Call the methods from the main method multiple times with different arguments.
|
||||||
|
|
||||||
|
## Return Values
|
||||||
|
|
||||||
|
* The return value of a method is *__returned__* with the `return` keyword:
|
||||||
|
```csharp
|
||||||
|
double CircleArea(double radius)
|
||||||
|
{
|
||||||
|
double area = Math.PI * radius * radius;
|
||||||
|
return area;
|
||||||
|
}
|
||||||
|
|
||||||
|
double radius = 2;
|
||||||
|
double result = CircleArea(radius);
|
||||||
|
Console.WriteLine(result); // Outputs 12,56637...
|
||||||
|
```
|
||||||
|
* In the first examples, the method declarations started with the `void` keyword, which means that the method doesn't return anything
|
||||||
|
* Here the method was declared as type `double` — now the method ***must*** return a `double` type variable
|
||||||
|
|
||||||
{
|
### Note about shortening
|
||||||
|
|
||||||
// Variable 'a' is only accessible inside of this method
|
* The earlier code
|
||||||
|
```csharp
|
||||||
|
double radius = 2;
|
||||||
|
double result = CircleArea(radius);
|
||||||
|
Console.WriteLine(result);
|
||||||
|
```
|
||||||
|
* can be shortened to
|
||||||
|
```csharp
|
||||||
|
double result = CircleArea(2);
|
||||||
|
Console.WriteLine(result);
|
||||||
|
```
|
||||||
|
* and even further into
|
||||||
|
```csharp
|
||||||
|
Console.WriteLine(CircleArea(2));
|
||||||
|
```
|
||||||
|
|
||||||
int a = 10;
|
## Using tuples for multiple return values
|
||||||
|
|
||||||
a = 20; // This works
|
* It is possible to return multiple values in the form of a *__tuple__*:
|
||||||
|
```csharp
|
||||||
|
|
||||||
}
|
(string, string) FirstAndLastName(string fullname)
|
||||||
|
{
|
||||||
|
string[] names = fullname.Split(' ');
|
||||||
|
return (names[0], names[names.Length - 1]);
|
||||||
|
}
|
||||||
|
|
||||||
a = 30; // This throws an error
|
(string first, string last) = FirstAndLastName("Hans \"Dolph\" Lundgren");
|
||||||
|
|
||||||
# Exercise 2
|
Console.WriteLine($"First name: {first}, last name: {last}");
|
||||||
|
// Outputs "First name: Hans, last name: Lundgren"
|
||||||
|
```
|
||||||
|
* ***Note:*** If only one value from a tuple is needed, you can use a *__discard__* (`_`)
|
||||||
|
```csharp
|
||||||
|
// Only the last name is allocated to a variable
|
||||||
|
(_, string lastName) = FirstAndLastName("Arnold Alois Schwarzenegger");
|
||||||
|
```
|
||||||
|
|
||||||
Write a method that takes a string as a parameter and prints the total number of spaces in that string.
|
## Scope of methods
|
||||||
|
|
||||||
Without using the string.Trim() method, modify the method so that it removes the spaces in a string and returns the new string.
|
* The variables declared inside a method are *__local variables__* and only accessible inside the method
|
||||||
|
```csharp
|
||||||
|
void ScopeExample()
|
||||||
|
{
|
||||||
|
// Variable 'a' is only accessible inside of this method
|
||||||
|
int a = 10;
|
||||||
|
a = 20; // This works
|
||||||
|
}
|
||||||
|
a = 30; // This throws an error
|
||||||
|
```
|
||||||
|
|
||||||
(Hint: You can iterate a string just like arrays and lists.)
|
* Contrastingly, variables declared outside the method are available inside, as seen in an earlier [example](#parameters-an-example)
|
||||||
|
|
||||||
|
## Exercise 2
|
||||||
|
<!--_class: "exercise invert" -->
|
||||||
|
|
||||||
|
1) Write a method that takes a string as a parameter and prints the total number of spaces in that string.
|
||||||
|
2) Without using the `string.Trim()` method, modify the method so that it removes the spaces in a string and returns a new string.
|
||||||
|
|
||||||
|
***Hint:*** You can iterate a string just like arrays and lists.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
## Exercise 3
|
||||||
|
<!--_class: "exercise invert" -->
|
||||||
|
|
||||||
|
<div class='columns' markdown='1'>
|
||||||
|
<div markdown='1'>
|
||||||
|
|
||||||
# Exercise 3
|
1) Write a method that takes in a string as a parameter and prints each unique letter in that string.
|
||||||
|
2) Write a new method that takes a string as a parameter and prints the number of each unique letter in the string.
|
||||||
|
|
||||||
Write a method that takes a string as a parameter and prints each unique letter in that string.
|
</div>
|
||||||
|
<div markdown='1'>
|
||||||
|
|
||||||
Write a new method that takes a string as a parameter and prints the number of each unique letter in the string.
|
|
||||||
|
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
# Exercise 4
|
## Exercise 4
|
||||||
|
<!--_class: "exercise invert" -->
|
||||||
|
|
||||||
Write a method that takes a 10 digit number as a parameter and divides individual digits into even and odd arrays. Method should return both arrays.
|
* Write a method that takes in a 10-digit number as a parameter and divides individual digits into two arrays of even and odd digits. The method should return both arrays.
|
||||||
|
* Remember to check that method only accepts numbers!
|
||||||
|
|
||||||
Remember to check that method accepts only numbers.
|
## Exercise 5
|
||||||
|
<!--_class: "exercise invert" -->
|
||||||
|
|
||||||
# Assignments
|
* Fix this [example](#parameters-an-example) that utilized a bad practice where a variable declared outside the function is modified inside the function.
|
||||||
|
* So instead, take in the `centuriesPrinted` variable as another parameter, modify it in the function, and then return it.
|
||||||
|
|
||||||
[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/6.%20Methods)
|
## Assignments
|
||||||
|
|
||||||
|
[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/6.%20Methods)
|
||||||
Loading…
Reference in New Issue