1188 lines
35 KiB
Markdown
1188 lines
35 KiB
Markdown
# Create methods in C# console applications
|
||
|
||
Learn how to create methods for C# console applications. Use parameters and
|
||
return values to manipulate data across applications. Learn to use named and
|
||
optional arguments to simplify code.
|
||
|
||
## Introduction
|
||
|
||
The C# programming language allows you to create all sorts of robust
|
||
applications. Suppose you want to write code to perform operations on
|
||
unpredictable user input. You might want to add logic to handle incorrect input,
|
||
convert input into a workable format, and perform the correct operation. As your
|
||
applications grow larger in size, keeping track of your code can quickly become
|
||
a challenge.
|
||
|
||
Methods, also called functions, are a key part of keeping code structured,
|
||
efficient, and readable. A method is a modular unit of code, and a fundamental
|
||
programming concept. A method is often designed to perform a specific task and
|
||
contains code to execute that task. The name of a method should clearly reflect
|
||
its task, which improves code readability. Learning how to use methods will help
|
||
you build feature-rich applications more quickly.
|
||
|
||
In this module, you'll learn to create your own methods to perform specific
|
||
tasks. You'll learn how methods can simplify and shorten code, as well as keep
|
||
things organized and easy to find.
|
||
|
||
### Learning Objectives
|
||
|
||
In this module, you will:
|
||
|
||
- Create your first c sharp method
|
||
- Identify parts of code that can be modularized
|
||
- Use methods to organize code into specific tasks
|
||
|
||
---
|
||
|
||
### Understand the syntax of methods
|
||
|
||
You might already be familiar with some methods, such as `Console.WriteLine()`
|
||
or `random.Next()`. You might have appreciated how these methods simplify tasks
|
||
and allow you to build your code more easily. In this unit, you'll learn how to
|
||
create your own methods.
|
||
|
||
### How methods work
|
||
|
||
The process of developing a method begins with creating a method signature. The
|
||
method signature declares the method's return type, name, and input parameters.
|
||
For example, consider the following method signature:
|
||
|
||
```cs
|
||
void SayHello();
|
||
```
|
||
|
||
The method name is `SayHello`. Its return type is `void`, meaning the method
|
||
returns no data. However, methods can return a value of any data type, such as
|
||
`bool`, `int`, `double`, and arrays as well. Method parameters, if any, should
|
||
be included in the parenthesis `()`. Methods can accept multiple parameters of
|
||
any data type. In this example, the method has no parameters.
|
||
|
||
Before you can run a method, you need to add a definition. The method
|
||
definition uses brackets `{}` to contain the code that executes when the method
|
||
is called. For example:
|
||
|
||
```cs
|
||
void SayHello() {
|
||
Console.WriteLine("Hello World!");
|
||
}
|
||
```
|
||
|
||
Now the method will print `Hello World!` whenever it's called.
|
||
|
||
#### Calling a method
|
||
|
||
A method is called by using its name and including any required arguments.
|
||
Consider the following:
|
||
|
||
```cs
|
||
Console.Write("Input!");
|
||
```
|
||
|
||
The string `"Input!"` is the argument provided to the `Write` method.
|
||
|
||
A method can be called before or after its definition. For example, the
|
||
`SayHello` method can be defined and called using the following syntax:
|
||
|
||
```cs
|
||
SayHello();
|
||
|
||
void SayHello() {
|
||
Console.WriteLine("Hello World!");
|
||
}
|
||
```
|
||
|
||
Notice that it isn't necessary to have the method defined before you call it.
|
||
This flexibility allows you to organize your code as you see fit. It's common
|
||
to define all methods at the end of a program. For example:
|
||
|
||
```cs
|
||
int[] a = {1,2,3,4,5};
|
||
|
||
Console.WriteLine("Contents of Array:");
|
||
PrintArray();
|
||
|
||
void PrintArray() {
|
||
foreach (int x in a) {
|
||
Console.Write($"{x} ");
|
||
}
|
||
Console.WriteLine();
|
||
}
|
||
```
|
||
|
||
### Method execution
|
||
|
||
When you call a method, the code in the method body will be executed. This
|
||
means execution control is passed from the method caller to the method. Control
|
||
is returned to the caller after the method completes its execution. For example,
|
||
consider the following code:
|
||
|
||
```cs
|
||
Console.WriteLine("Before calling a method");
|
||
SayHello();
|
||
Console.WriteLine("After calling a method");
|
||
|
||
void SayHello() {
|
||
Console.WriteLine("Hello World!");
|
||
}
|
||
```
|
||
|
||
This code displays the following output:
|
||
|
||
```txt
|
||
Before calling a method
|
||
Hello World!
|
||
After calling a method
|
||
```
|
||
|
||
Once a method is defined, it can be called anytime, as many times as you need
|
||
to use it. You can use methods inside of `if-else` statements, `for`-loops,
|
||
`switch` statements, even to initialize variables, and so much more!
|
||
|
||
#### Best practices
|
||
|
||
When choosing a method name, it's important to keep the name concise and make
|
||
it clear what task the method performs. Method names should be Pascal case and
|
||
generally shouldn't start with digits. Names for parameters should describe
|
||
what kind of information the parameter represents. Consider the following
|
||
method signatures:
|
||
|
||
```cs
|
||
void ShowData(string a, int b, int c);
|
||
void DisplayDate(string month, int day, int year);
|
||
```
|
||
|
||
The second method describes what kind of data is displayed and provides
|
||
descriptive names for parameters.
|
||
|
||
Now that you have the basics down, you're ready to begin writing your own
|
||
methods!
|
||
|
||
---
|
||
|
||
## Exercise
|
||
|
||
### Create your first method
|
||
|
||
Typically, a method is created to perform a specific task. In this exercise,
|
||
you'll create a method that generates and displays five random numbers. Let's
|
||
get started!
|
||
|
||
#### Create a method to display random numbers
|
||
|
||
To create a method, first create a method signature and then add the method
|
||
body. To create the method signature, you declare the return type, method name,
|
||
and parameters. Create the method body by using brackets `{}` that contain the
|
||
code.
|
||
|
||
Enter the following code into the Visual Studio Code editor:
|
||
|
||
```cs
|
||
void DisplayRandomNumbers();
|
||
```
|
||
|
||
In this case, the method just needs to generate and display information, so the
|
||
return type is `void`. For now, you don't need to include any parameters.
|
||
|
||
To create the method body, remove the semicolon `;` and update your code to the
|
||
following:
|
||
|
||
```cs
|
||
void DisplayRandomNumbers() {
|
||
Random random = new Random();
|
||
}
|
||
```
|
||
|
||
Here, you create a `Random` object that is used to generate the numbers.
|
||
|
||
To display five random integers, add a `for` loop to your method:
|
||
|
||
```cs
|
||
void DisplayRandomNumbers() {
|
||
Random random = new Random();
|
||
|
||
for (int i = 0; i < 5; i++) {
|
||
Console.Write($"{random.Next(1, 100)} ");
|
||
}
|
||
}
|
||
```
|
||
|
||
In this code, you generate a number between 1 and 99 (inclusive). You also add
|
||
a space after the number is printed. Next, you'll display a new line before the
|
||
method terminates.
|
||
|
||
Update your method with the following code:
|
||
|
||
```cs
|
||
void DisplayRandomNumbers() {
|
||
Random random = new Random();
|
||
for (int i = 0; i < 5; i++) {
|
||
Console.Write($"{random.Next(1, 100)} ");
|
||
}
|
||
Console.WriteLine();
|
||
}
|
||
```
|
||
|
||
Now your method will add a new line after displaying the numbers.
|
||
|
||
#### Call your method
|
||
|
||
Enter a new blank code line above the `DisplayRandomNumbers` method.
|
||
|
||
Enter the following code on the new blank code line:
|
||
|
||
```cs
|
||
Console.WriteLine("Generating random numbers:");
|
||
DisplayRandomNumbers();
|
||
```
|
||
|
||
Compare your code with the following to ensure it's correct:
|
||
|
||
```cs
|
||
Console.WriteLine("Generating random numbers:");
|
||
DisplayRandomNumbers();
|
||
|
||
void DisplayRandomNumbers() {
|
||
Random random = new Random();
|
||
|
||
for (int i = 0; i < 5; i++) {
|
||
Console.Write($"{random.Next(1, 100)} ");
|
||
}
|
||
|
||
Console.WriteLine();
|
||
}
|
||
```
|
||
|
||
Notice how using a method makes the code easy to understand. Rather than
|
||
spending time trying to decipher the `for` loop on its own, you can quickly
|
||
read the method name to learn that this code displays random numbers.
|
||
|
||
### Check Your Work
|
||
|
||
In this task, you'll run your application from the Integrated Terminal and
|
||
verify your code is working correctly. Let's get started.
|
||
|
||
At the Terminal command prompt, enter `dotnet run`
|
||
|
||
To verify that your code is working as expected, check that the output of your
|
||
application is similar to the following output (taking into account the
|
||
randomly generated numbers):
|
||
|
||
```cs
|
||
17 29 46 36 3
|
||
```
|
||
|
||
If your code displays different results, you'll need to review your code to
|
||
find your error and make updates. Run the code again to see if you've fixed the
|
||
problem. Continue updating and running your code until your code produces the
|
||
expected results.
|
||
|
||
### Recap
|
||
|
||
Here's what you've learned about methods so far:
|
||
|
||
- Create a method by declaring the return type, name, input parameters, and method body.
|
||
- Method names should clearly reflect the task the method performs.
|
||
- Use a method by calling its name and including parentheses ().
|
||
|
||
---
|
||
|
||
## Exercise
|
||
|
||
### Create reusable methods
|
||
|
||
As you develop applications, you might find yourself writing code to do the
|
||
same thing over and over again. Instead of writing duplicate code, using a
|
||
method to perform the same task shortens your code and helps you develop
|
||
applications faster. In this exercise, you'll identify repeated code and
|
||
replace it with a reusable method. Let's get started!
|
||
|
||
#### Identify duplicated code
|
||
|
||
In this task, you'll take a look at an application that tracks medication times
|
||
across different time zones. The user enters their current time zone and their
|
||
destination time zone. Their medication schedule is displayed and then adjusted
|
||
for the new time zone.
|
||
|
||
In the code editor, delete any existing code from the previous exercises.
|
||
|
||
Copy and paste the following code:
|
||
|
||
```cs
|
||
using System;
|
||
|
||
int[] times = {800, 1200, 1600, 2000};
|
||
int diff = 0;
|
||
|
||
Console.WriteLine("Enter current GMT");
|
||
int currentGMT = Convert.ToInt32(Console.ReadLine());
|
||
|
||
Console.WriteLine("Current Medicine Schedule:");
|
||
|
||
/* Format and display medicine times */
|
||
foreach (int val in times) {
|
||
string time = val.ToString();
|
||
int len = time.Length;
|
||
if (len >= 3) {
|
||
time = time.Insert(len - 2, ":");
|
||
}
|
||
else if (len == 2) {
|
||
time = time.Insert(0, "0:");
|
||
} else {
|
||
time = time.Insert(0, "0:0");
|
||
}
|
||
Console.Write($"{time} ");
|
||
}
|
||
|
||
Console.WriteLine();
|
||
|
||
Console.WriteLine("Enter new GMT");
|
||
int newGMT = Convert.ToInt32(Console.ReadLine());
|
||
|
||
if (Math.Abs(newGMT) > 12 || Math.Abs(currentGMT) > 12) {
|
||
Console.WriteLine("Invalid GMT");
|
||
} else if (newGMT <= 0 && currentGMT <= 0 || newGMT >= 0 && currentGMT >= 0) {
|
||
diff = 100 * (Math.Abs(newGMT) - Math.Abs(currentGMT));
|
||
/* Adjust the times by adding the difference, keeping the value within 24 hours */
|
||
for (int i = 0; i < times.Length; i++) {
|
||
times[i] = ((times[i] + diff)) % 2400;
|
||
}
|
||
} else {
|
||
diff = 100 * (Math.Abs(newGMT) + Math.Abs(currentGMT));
|
||
/* Adjust the times by adding the difference, keeping the value within 24 hours */
|
||
for (int i = 0; i < times.Length; i++) {
|
||
times[i] = ((times[i] + diff)) % 2400;
|
||
}
|
||
}
|
||
|
||
Console.WriteLine("New Medicine Schedule:");
|
||
|
||
/* Format and display medicine times */
|
||
foreach (int val in times) {
|
||
string time = val.ToString();
|
||
int len = time.Length;
|
||
if (len >= 3) {
|
||
time = time.Insert(len - 2, ":");
|
||
} else if (len == 2) {
|
||
time = time.Insert(0, "0:");
|
||
} else {
|
||
time = time.Insert(0, "0:0");
|
||
}
|
||
Console.Write($"{time} ");
|
||
}
|
||
|
||
Console.WriteLine();
|
||
```
|
||
|
||
Notice that there's several `for`-loops that are repeated with identical code.
|
||
|
||
There are two `foreach` loops that format and display the medicine times. There
|
||
are another two `for` loops that adjust the times according to the time zone
|
||
difference.
|
||
|
||
As you write code, you might find yourself repeating blocks of code to do the
|
||
same task. That's a perfect opportunity to consolidate your code by using a
|
||
method to perform the task instead. Let's practice!
|
||
|
||
#### Create methods to perform the repeated tasks
|
||
|
||
Now that you've identified repeated code, you can create a method to contain
|
||
the code and remove the duplicates. Using methods has the added bonus of
|
||
shortening your code and improving readability! The `foreach` loops format and
|
||
display the time values, so you can give the method a name that clearly
|
||
reflects that task. You can do the same with the `for` loop that adjusts the
|
||
times. Let's get started!
|
||
|
||
Enter a new blank code line at the end of the previous code.
|
||
|
||
On the new blank code line, create a method signature by entering the following
|
||
code:
|
||
|
||
```cs
|
||
void DisplayTimes() {
|
||
|
||
}
|
||
```
|
||
|
||
To define the method body, update the DisplayTimes method by copy and pasting
|
||
the foreach block as follows:
|
||
|
||
```cs
|
||
void DisplayTimes() {
|
||
/* Format and display medicine times */
|
||
foreach (int val in times) {
|
||
string time = val.ToString();
|
||
int len = time.Length;
|
||
if (len >= 3) {
|
||
time = time.Insert(len - 2, ":");
|
||
} else if (len == 2) {
|
||
time = time.Insert(0, "0:");
|
||
} else {
|
||
time = time.Insert(0, "0:0");
|
||
}
|
||
Console.Write($"{time} ");
|
||
}
|
||
|
||
Console.WriteLine();
|
||
}
|
||
```
|
||
|
||
In this method, you include the call to `Console.WriteLine` at the end to
|
||
append a new line after the times are displayed. Next, you'll create another
|
||
method to adjust the times according to the time zone difference.
|
||
|
||
Enter a new blank code line at the end of the previous code.
|
||
|
||
On the new blank code line, create a method signature by entering the following
|
||
code:
|
||
|
||
```cs
|
||
void AdjustTimes() {
|
||
|
||
}
|
||
```
|
||
|
||
Update the `AdjustTimes` method by copy and pasting the `for` loop as follows:
|
||
|
||
```cs
|
||
void AdjustTimes() {
|
||
/* Adjust the times by adding the difference, keeping the value within 24 hours */
|
||
for (int i = 0; i < times.Length; i++) {
|
||
times[i] = ((times[i] + diff)) % 2400;
|
||
}
|
||
}
|
||
```
|
||
|
||
#### Step 3: Call the methods
|
||
|
||
In this task, you'll delete the repeated blocks of code and replace them with
|
||
calls to the methods you created.
|
||
|
||
Locate the first instance of the repeated `foreach` loop under the comment
|
||
"Format and display medicine times":
|
||
|
||
```cs
|
||
Console.WriteLine("Current Medicine Schedule:");
|
||
|
||
/* Format and display medicine times */
|
||
foreach (int val in times) {
|
||
...
|
||
}
|
||
|
||
Console.WriteLine();
|
||
|
||
Console.WriteLine("Enter new GMT");
|
||
```
|
||
|
||
Replace the code you identified with a call to the `DisplayTimes` method. The
|
||
replacement should result in the following code:
|
||
|
||
```cs
|
||
Console.WriteLine("Current Medicine Schedule:");
|
||
DisplayTimes();
|
||
|
||
Console.WriteLine("Enter new GMT");
|
||
```
|
||
|
||
Next, you'll replace the second instance of the repeated code.
|
||
|
||
Locate the second instance of the `foreach` loop under the comment "Format and
|
||
display medicine times":
|
||
|
||
```cs
|
||
Console.WriteLine("New Medicine Schedule:");
|
||
|
||
/* Format and display medicine times */
|
||
foreach (int val in times) {
|
||
...
|
||
}
|
||
|
||
Console.WriteLine();
|
||
```
|
||
|
||
Replace the code you identified with a call to the `DisplayTimes` method. The
|
||
replacement should result in the following code:
|
||
|
||
```cs
|
||
Console.WriteLine("New Medicine Schedule:");
|
||
DisplayTimes();
|
||
```
|
||
|
||
Notice how using a method in place of a large block of code provides more
|
||
clarity and makes the code easier to understand. Let's do the same with the
|
||
`AdjustTimes` method you created.
|
||
|
||
Locate the following code with the duplicated `for`-loops:
|
||
|
||
```cs
|
||
else if (newGMT <= 0 && currentGMT <= 0 || newGMT >= 0 && currentGMT >= 0) {
|
||
diff = 100 * (Math.Abs(newGMT) - Math.Abs(currentGMT));
|
||
/* Adjust the times by adding the difference, keeping the value within 24 hours */
|
||
for (int i = 0; i < times.Length; i++) {
|
||
times[i] = ((times[i] + diff)) % 2400;
|
||
}
|
||
} else {
|
||
diff = 100 * (Math.Abs(newGMT) + Math.Abs(currentGMT));
|
||
|
||
/* Adjust the times by adding the difference, keeping the value within 24 hours */
|
||
for (int i = 0; i < times.Length; i++) {
|
||
times[i] = ((times[i] + diff)) % 2400;
|
||
}
|
||
}
|
||
```
|
||
|
||
Replace the instances of repeated code under the comment "Adjust the times by
|
||
adding the difference" with calls to your `AdjustTimes` method. The replacement
|
||
should result in the following code:
|
||
|
||
```cs
|
||
else if (newGMT <= 0 && currentGMT <= 0 || newGMT >= 0 && currentGMT >= 0) {
|
||
diff = 100 * (Math.Abs(newGMT) - Math.Abs(currentGMT));
|
||
AdjustTimes();
|
||
} else {
|
||
diff = 100 * (Math.Abs(newGMT) + Math.Abs(currentGMT));
|
||
AdjustTimes();
|
||
}
|
||
```
|
||
|
||
Now all of the duplicated code has been replaced by your new method. Notice how
|
||
much more readable and concise your code looks!
|
||
|
||
### Check Your Work
|
||
|
||
In this task, you'll run your application from the Integrated Terminal and
|
||
verify your code is working correctly. Let's get started.
|
||
|
||
Compare your code with the following to ensure it's correct:
|
||
|
||
```cs
|
||
int[] times = {800, 1200, 1600, 2000};
|
||
int diff = 0;
|
||
|
||
Console.WriteLine("Enter current GMT");
|
||
int currentGMT = Convert.ToInt32(Console.ReadLine());
|
||
|
||
Console.WriteLine("Current Medicine Schedule:");
|
||
DisplayTimes();
|
||
|
||
Console.WriteLine("Enter new GMT");
|
||
int newGMT = Convert.ToInt32(Console.ReadLine());
|
||
|
||
if (Math.Abs(newGMT) > 12 || Math.Abs(currentGMT) > 12) {
|
||
Console.WriteLine("Invalid GMT");
|
||
} else if (newGMT <= 0 && currentGMT <= 0 || newGMT >= 0 && currentGMT >= 0) {
|
||
diff = 100 * (Math.Abs(newGMT) - Math.Abs(currentGMT));
|
||
AdjustTimes();
|
||
} else {
|
||
diff = 100 * (Math.Abs(newGMT) + Math.Abs(currentGMT));
|
||
AdjustTimes();
|
||
}
|
||
|
||
Console.WriteLine("New Medicine Schedule:");
|
||
DisplayTimes();
|
||
|
||
void DisplayTimes() {
|
||
/* Format and display medicine times */
|
||
foreach (int val in times) {
|
||
string time = val.ToString();
|
||
int len = time.Length;
|
||
if (len >= 3) {
|
||
time = time.Insert(len - 2, ":");
|
||
} else if (len == 2) {
|
||
time = time.Insert(0, "0:");
|
||
} else {
|
||
time = time.Insert(0, "0:0");
|
||
}
|
||
Console.Write($"{time} ");
|
||
}
|
||
Console.WriteLine();
|
||
}
|
||
|
||
void AdjustTimes() {
|
||
/* Adjust the times by adding the difference, keeping the value within 24 hours */
|
||
for (int i = 0; i < times.Length; i++) {
|
||
times[i] = ((times[i] + diff)) % 2400;
|
||
}
|
||
}
|
||
```
|
||
|
||
At the Terminal command prompt, enter `dotnet run`
|
||
|
||
Enter -6 and +6 for the GMT prompts.
|
||
|
||
Verify that your code produces the following output:
|
||
|
||
```txt
|
||
Enter current GMT
|
||
-6
|
||
Current Medicine Schedule:
|
||
8:00 12:00 16:00 20:00
|
||
Enter new GMT
|
||
+6
|
||
New Medicine Schedule:
|
||
20:00 0:00 4:00 8:00
|
||
```
|
||
|
||
If your code displays different results, you'll need to review your code to
|
||
find your error and make updates. Run the code again to see if you've fixed the
|
||
problem. Continue updating and running your code until your code produces the
|
||
expected results.
|
||
|
||
---
|
||
|
||
## Exercise
|
||
|
||
### Build code with methods
|
||
|
||
Methods are useful for organizing code, reusing code, and for tackling problems
|
||
efficiently. You can think of a method like a black box that takes input,
|
||
performs the named task, and returns output. With this assumption, you can
|
||
quickly structure programs just by naming your tasks as methods, and then
|
||
filling in the logic after you've identified all of the necessary tasks.
|
||
|
||
When you use plain language to describe steps in code, without strictly
|
||
adhering to syntax rules, you're using "pseudo-code". Combining methods and
|
||
pseudo-code is a great way to quickly power through any challenging programming
|
||
task.
|
||
|
||
### Use methods to structure code
|
||
|
||
Suppose you're a candidate in a coding interview. The interviewer wants you to
|
||
write a program that checks whether an IPv4 address is valid or invalid. You're
|
||
given the following rules:
|
||
|
||
- A valid IPv4 address consists of four numbers separated by dots
|
||
- Each number must not contain leading zeroes
|
||
- Each number must range from 0 to 255
|
||
|
||
1.1.1.1 and 255.255.255.255 are examples of valid IP addresses.
|
||
|
||
The IPv4 address is provided as a string. You can assume that it only consists
|
||
of digits and dots (there are no letters in the string provided).
|
||
|
||
How would you approach this task?
|
||
|
||
> Note
|
||
> Even if you aren't familiar with IP addresses, don't worry! You can still
|
||
complete the code in this exercise by following the steps.
|
||
|
||
#### Break down the problem
|
||
|
||
In this task, you'll identify the steps needed to solve the problem. If you look
|
||
closely at the rules, you might realize that it only takes three steps to
|
||
determine whether or not an IPv4 address is valid.
|
||
|
||
Enter the following pseudo-code into the Editor:
|
||
|
||
```cs
|
||
/*
|
||
if ipAddress consists of 4 numbers
|
||
and
|
||
if each ipAddress number has no leading zeroes
|
||
and
|
||
if each ipAddress number is in range 0 - 255
|
||
|
||
then ipAddress is valid
|
||
|
||
else ipAddress is invalid
|
||
*/
|
||
```
|
||
|
||
Pseudo-code is a great way to begin tackling any problem. Using this comment
|
||
block, you bridge the gap between the prompt rules and the program code,
|
||
clarifying the major tasks your code will perform. Pseudo-code doesn't need to
|
||
be functional or adhere to syntax rules, however, it should be a clear
|
||
explanation of what the code will do. Now let's turn this into real code!
|
||
|
||
Enter a new blank code line, then type the following code in the Editor:
|
||
|
||
```cs
|
||
if (ValidateLength() && ValidateZeroes() && ValidateRange()) {
|
||
Console.WriteLine($"ip is a valid IPv4 address");
|
||
} else {
|
||
Console.WriteLine($"ip is an invalid IPv4 address");
|
||
}
|
||
```
|
||
|
||
In this step, you transform the `if` statements from your pseudo-code into
|
||
callable methods and output the results. Don't worry about defining the methods
|
||
yet; you can assume that each method performs the task its name describes.
|
||
You'll fix the compilation errors and create the method logic soon, but focus
|
||
on the big picture for now. When you begin working on a new program, focusing
|
||
on the overall design helps you stay organized and develop your application
|
||
faster.
|
||
|
||
Enter a new blank code line below the existing code, then type the following
|
||
code in the Editor:
|
||
|
||
```cs
|
||
void ValidateLength() {}
|
||
void ValidateZeroes() {}
|
||
void ValidateRange() {}
|
||
```
|
||
|
||
Notice how using placeholder methods allowed you to quickly approach the problem
|
||
and structure your code to develop the solution. Now that you have a structured
|
||
plan in place, you can continue to solve the problem by filling in the code
|
||
piece by piece.
|
||
|
||
#### Develop your solution
|
||
|
||
Now that you have all the placeholder methods needed to solve the problem, you
|
||
can begin to focus on the details of your solution. Keep in mind that the input
|
||
format of the IPv4 address will be a string consisting of digits separated by
|
||
dots. Let's get stared!
|
||
|
||
At the beginning of your program, create variables to store the input and
|
||
validation statuses:
|
||
|
||
```cs
|
||
string ipv4Input = "107.31.1.5";
|
||
bool validLength = false;
|
||
bool validZeroes = false;
|
||
bool validRange = false;
|
||
```
|
||
|
||
Update your solution code to use the validation variables as follows:
|
||
|
||
```cs
|
||
ValidateLength();
|
||
ValidateZeroes();
|
||
ValidateRange();
|
||
|
||
if (validLength && validZeroes && validRange) {
|
||
Console.WriteLine($"ip is a valid IPv4 address");
|
||
} else {
|
||
Console.WriteLine($"ip is an invalid IPv4 address");
|
||
}
|
||
```
|
||
|
||
Update the `ValidateLength` method as follows:
|
||
|
||
```cs
|
||
void ValidateLength() {
|
||
string[] address = ipv4Input.Split(".");
|
||
validLength = address.Length == 4;
|
||
};
|
||
```
|
||
|
||
The first rule states that the IPv4 address needs to have four numbers. So in
|
||
this code, you use `string.Split` to separate the digits and check that there are
|
||
four of them.
|
||
|
||
Update the `ValidateZeroes` method as follows:
|
||
|
||
```cs
|
||
void ValidateZeroes() {
|
||
string[] address = ipv4Input.Split(".");
|
||
foreach (string number in address) {
|
||
if (number.Length > 1 && number.StartsWith("0")) {
|
||
validZeroes = false;
|
||
}
|
||
}
|
||
validZeroes = true;
|
||
}
|
||
```
|
||
|
||
Take a moment to consider how the rule translates to code.
|
||
|
||
The second rule states that the numbers in the IPv4 address must not contain
|
||
leading zeroes. So the method needs to check numbers for leading zeroes while
|
||
accepting `0` as a valid number. If all the numbers have valid zeroes,
|
||
`validZeroes` should be equal to `true`, and `false` otherwise. So in this code,
|
||
you check that each number with more than one digit does not begin with a zero.
|
||
|
||
If you look closely, you'll notice that `validZeroes` is set to true after the
|
||
foreach loop completes. However, you only want to set `validZeroes` to `true`
|
||
if no leading zeroes are found. You could correct this bug by setting
|
||
`validZeroes = true` before the `foreach` loop runs. However, you can also
|
||
correct this bug using a return statement.
|
||
|
||
Update your code to the following:
|
||
|
||
```cs
|
||
foreach (string number in address) {
|
||
if (number.Length > 1 && number.StartsWith("0")) {
|
||
validZeroes = false;
|
||
return;
|
||
}
|
||
}
|
||
```
|
||
|
||
The **return** statement terminates execution of the method and returns control
|
||
to the method caller. Adding a `return` statement after `validZeroes = false`
|
||
terminates the method after the first invalid zero is found. If no invalid zero
|
||
is found, the method will terminate after setting `validZeroes` to `true`. Let's
|
||
move on to the next method.
|
||
|
||
Update the `ValidateRange` method as follows:
|
||
|
||
```cs
|
||
void ValidateRange() {
|
||
string[] address = ipv4Input.Split(".");
|
||
|
||
foreach (string number in address) {
|
||
int value = int.Parse(number);
|
||
if (value < 0 || value > 255) {
|
||
validRange = false;
|
||
return;
|
||
}
|
||
}
|
||
validRange = true;
|
||
}
|
||
```
|
||
|
||
The third rule states that each number in the IPv4 address must range from 0 to
|
||
255. So in this code, you check that each number is less than 255, and if not,
|
||
terminate execution after setting `validRange` to `false`. Since the input
|
||
string only contains digits and dots, you don't need to check for negative
|
||
numbers.
|
||
|
||
However, there might be a case where no digits are present between dots. For
|
||
example, "255...255". In this case, `string.Split(".")` would return empty
|
||
entries, causing `int.Parse` to fail. You can prevent this by specifying
|
||
`StringSplitOptions`.
|
||
|
||
Update your code as follows:
|
||
|
||
```cs
|
||
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
|
||
```
|
||
|
||
Using `StringSplitOptions.RemoveEmptyEntries` omits empty entries from the
|
||
`address` array and prevent attempts to parse empty strings.
|
||
|
||
#### Complete your solution
|
||
|
||
Now that you have all the methods completed to validate an IP address, it's
|
||
time to revisit your initial solution. In this task, you'll add more input
|
||
values and prepare to test your code.
|
||
|
||
Locate the following code you wrote earlier in the program:
|
||
|
||
```cs
|
||
string ipv4Input = "107.31.1.5";
|
||
```
|
||
|
||
Update the code as follows:
|
||

|
||
```cs
|
||
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
|
||
```
|
||
|
||
When developing a solution, it is important to test your code with different
|
||
input cases. In this code, you provide a decent range of test values. Now that
|
||
you've updated your test input, you'll need to update your code to use the new
|
||
values. Since the values are in an array, you'll need to update your code to
|
||
test each one using a loop.
|
||
|
||
Update your code as follows:
|
||
|
||
```cs
|
||
foreach (string ip in ipv4Input) {
|
||
ValidateLength();
|
||
ValidateZeroes();
|
||
ValidateRange();
|
||
|
||
if (validLength && validZeroes && validRange) {
|
||
Console.WriteLine($"{ip} is a valid IPv4 address");
|
||
} else {
|
||
Console.WriteLine($"{ip} is an invalid IPv4 address");
|
||
}
|
||
}
|
||
```
|
||
|
||
Lastly, you need to fix the input data each method uses since you updated
|
||
`ipv4Input` from a string to an array. Since each method uses `string.Split`,
|
||
you can declare a variable to store the result of `string.Split` and use it in
|
||
each method instead.
|
||
|
||
Add a variable to store the current IPv4 address that each method will
|
||
reference:
|
||
|
||
```cs
|
||
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
|
||
string[] address;
|
||
bool validLength = false;
|
||
bool validZeroes = false;
|
||
bool validRange = false;
|
||
```
|
||
|
||
Initialize `address` using `string.Split` as follows:
|
||
|
||
```cs
|
||
foreach (string ip in ipv4Input) {
|
||
address = ip.Split(".", StringSplitOptions.RemoveEmptyEntries);
|
||
```
|
||
Remove references to `string.Split` from each of the validation methods so that
|
||
they use the global `address` variable instead. For example:
|
||
|
||
```cs
|
||
void ValidateLength() {
|
||
validLength = address.Length == 4;
|
||
};
|
||
```
|
||
|
||
### Check Your Work
|
||
|
||
In this task, you'll run your application from the Integrated Terminal and
|
||
verify your code is working correctly. Let's get started.
|
||
|
||
Compare your code with the following to ensure it is correct:
|
||
|
||
```cs
|
||
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
|
||
string[] address;
|
||
bool validLength = false;
|
||
bool validZeroes = false;
|
||
bool validRange = false;
|
||
|
||
foreach (string ip in ipv4Input) {
|
||
address = ip.Split(".", StringSplitOptions.RemoveEmptyEntries);
|
||
ValidateLength();
|
||
ValidateZeroes();
|
||
ValidateRange();
|
||
if (validLength && validZeroes && validRange) {
|
||
Console.WriteLine($"{ip} is a valid IPv4 address");
|
||
} else {
|
||
Console.WriteLine($"{ip} is an invalid IPv4 address");
|
||
}
|
||
}
|
||
|
||
void ValidateLength() {
|
||
validLength = address.Length == 4;
|
||
};
|
||
|
||
void ValidateZeroes() {
|
||
foreach (string number in address) {
|
||
if (number.Length > 1 && number.StartsWith("0")) {
|
||
validZeroes = false;
|
||
return;
|
||
}
|
||
}
|
||
validZeroes = true;
|
||
}
|
||
|
||
void ValidateRange() {
|
||
foreach (string number in address) {
|
||
int value = int.Parse(number);
|
||
if (value < 0 || value > 255) {
|
||
validRange = false;
|
||
return;
|
||
}
|
||
}
|
||
validRange = true;
|
||
}
|
||
```
|
||
|
||
At the Terminal command prompt, enter `dotnet run`
|
||
|
||
Verify that your code produces the following output:
|
||
|
||
```txt
|
||
107.31.1.5 is a valid IPv4 address
|
||
255.0.0.255 is a valid IPv4 address
|
||
555..0.555 is an invalid IPv4 address
|
||
255...255 is an invalid IPv4 address
|
||
```
|
||
|
||
If your code displays different results, you'll need to review your code to
|
||
find your error and make updates. Run the code again to see if you've fixed the
|
||
problem. Continue updating and running your code until your code produces the
|
||
expected results.
|
||
|
||
### Recap
|
||
|
||
Here's what you've learned about using methods so far:
|
||
|
||
- Methods can be used to quickly structure applications
|
||
- The `return` keyword can be used to terminate method execution
|
||
- Each step of a problem can often be translated into its own method
|
||
- Use methods to solve small problems to build up your solution
|
||
|
||
---
|
||
|
||
## Exercise - Complete the challenge to create a reusable method
|
||
|
||
Code challenges reinforce what you've learned, and help you gain some
|
||
confidence before continuing on.
|
||
|
||
The focus of this challenge is to modify code so that it is reusable and can be
|
||
executed at any time.
|
||
|
||
### Tell a fortune
|
||
|
||
You're helping to develop a massive multiplayer role-playing game. Each player
|
||
has a luck stat that can affect their odds of finding rare treasure. Each day,
|
||
a player can speak to an in-game fortune teller that reveals whether their luck
|
||
stat is high, low, or neutral.
|
||
|
||
The game currently has code to generate a player's fortune, but it isn't
|
||
reusable. Your task is to create a `tellFortune` method that can be called at
|
||
any time, and replace the existing logic with a call to your method.
|
||
|
||
In this challenge, you're given some starting code. You must decide how to
|
||
create and call the `tellFortune` method.
|
||
|
||
#### Code challenge: create a reusable method
|
||
|
||
In the code that you start with, there's a generic text array, followed by goo
|
||
d, bad, and neutral text arrays. Depending on the value of `luck`, one of the
|
||
arrays is selected and displayed alongside the generic text.
|
||
|
||
Your challenge is to create a reusable method that prints a player's fortune at
|
||
any time. The method should contain the logic that is already present in the
|
||
code provided.
|
||
|
||
Copy and paste the following code into the Editor:
|
||
|
||
```cs
|
||
Random random = new Random();
|
||
int luck = random.Next(100);
|
||
|
||
string[] text = {
|
||
"You have much to",
|
||
"Today is a day to",
|
||
"Whatever work you do",
|
||
"This is an ideal time to"
|
||
};
|
||
string[] good = {
|
||
"look forward to.",
|
||
"try new things!",
|
||
"is likely to succeed.",
|
||
"accomplish your dreams!"
|
||
};
|
||
string[] bad = {
|
||
"fear.",
|
||
"avoid major decisions.",
|
||
"may have unexpected outcomes.",
|
||
"re-evaluate your life."
|
||
};
|
||
string[] neutral = {
|
||
"appreciate.",
|
||
"enjoy time with friends.",
|
||
"should align with your values.",
|
||
"get in tune with nature."
|
||
};
|
||
|
||
Console.WriteLine("A fortune teller whispers the following words:");
|
||
string[] fortune = (luck > 75 ? good : (luck < 25 ? bad : neutral));
|
||
for (int i = 0; i < 4; i++) {
|
||
Console.Write($"{text[i]} {fortune[i]} ");
|
||
}
|
||
```
|
||
|
||
Update the code to use a method to display the fortune.
|
||
|
||
Use what you've learned about creating and calling methods to complete the
|
||
update.
|
||
|
||
Test your code by changing the value of `luck` and calling the method again.
|
||
|
||
Verify that your code produces one of the following messages:
|
||
|
||
```txt
|
||
A fortune teller whispers the following words:
|
||
You have much to look forward to. Today is a day to try new things! Whatever work you do is likely to succeed. This is an ideal time to accomplish your dreams!
|
||
```
|
||
|
||
```txt
|
||
A fortune teller whispers the following words:
|
||
You have much to appreciate. Today is a day to enjoy time with friends. Whatever work you do should align with your values. This is an ideal time to get in tune with nature.
|
||
```
|
||
|
||
```txt
|
||
A fortune teller whispers the following words:
|
||
You have much to fear. Today is a day to avoid major decisions. Whatever work you do may have unexpected outcomes. This is an ideal time to re-evaluate your life.
|
||
```
|
||
|
||
Whether you get stuck and need to peek at the solution or you finish
|
||
successfully, continue on to view a solution to this challenge.
|
||
|
||
---
|
||
|
||
### Review the solution to create a reusable method
|
||
|
||
The following code is one possible solution for the challenge from the previous
|
||
unit.
|
||
|
||
```cs
|
||
Random random = new Random();
|
||
int luck = random.Next(100);
|
||
|
||
string[] text = {
|
||
"You have much to",
|
||
"Today is a day to",
|
||
"Whatever work you do",
|
||
"This is an ideal time to"
|
||
}
|
||
string[] good = {
|
||
"look forward to.",
|
||
"try new things!",
|
||
"is likely to succeed.",
|
||
"accomplish your dreams!"
|
||
};
|
||
string[] bad = {
|
||
"fear.",
|
||
"avoid major decisions.",
|
||
"may have unexpected outcomes.",
|
||
"re-evaluate your life."
|
||
};
|
||
string[] neutral = {
|
||
"appreciate.",
|
||
"enjoy time with friends.",
|
||
"should align with your values.",
|
||
"get in tune with nature."
|
||
};
|
||
|
||
TellFortune();
|
||
|
||
void TellFortune() {
|
||
Console.WriteLine("A fortune teller whispers the following words:");
|
||
string[] fortune = (luck > 75 ? good : (luck < 25 ? bad : neutral));
|
||
for (int i = 0; i < 4; i++) {
|
||
Console.Write($"{text[i]} {fortune[i]} ");
|
||
}
|
||
}
|
||
```
|
||
|
||
This code is just "one possible solution" because you might have added line
|
||
feeds in different spots or you might have formatted the code differently.
|
||
|
||
Regardless of minor code differences, when you run the code, you should see one
|
||
of the following output messages:
|
||
|
||
```txt
|
||
A fortune teller whispers the following words:
|
||
You have much to look forward to. Today is a day to try new things! Whatever work you do is likely to succeed. This is an ideal time to accomplish your dreams!
|
||
```
|
||
|
||
```txt
|
||
A fortune teller whispers the following words:
|
||
You have much to appreciate. Today is a day to enjoy time with friends. Whatever work you do should align with your values. This is an ideal time to get in tune with nature.
|
||
```
|
||
|
||
```txt
|
||
A fortune teller whispers the following words:
|
||
You have much to fear. Today is a day to avoid major decisions. Whatever work you do may have unexpected outcomes. This is an ideal time to re-evaluate your life.
|
||
```
|
||
|
||
The output should be dependent on the value of the `luck` variable.
|
||
|
||
If you completed the challenge, congratulations! Continue on to the knowledge
|
||
check in the next unit.
|
||
|
||
> Important
|
||
> If you had trouble completing this challenge, consider reviewing the previous
|
||
units before you continue on. All new ideas we discuss in other modules will
|
||
depend on your understanding of the ideas that were presented in this module.
|
||
|
||
---
|
||
|
||
## Summary
|
||
|
||
Your goal was to learn how to create your own methods to perform specific task
|
||
s. You learned to move reusable code into methods to minimize repeating code.
|
||
You also learned to use pseudo-code and placeholder methods to tackle a complex
|
||
problem. By creating small methods with specific responsibilities, you learned
|
||
to quickly build solutions for problems using efficient, readable code.
|