Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


Learn to recognize methods, call them with multiple arguments, capture their returned values, and define a basic method yourself.

Method Calls and Input

You've been using methods since you started learning C#! Commands like `Console.WriteLine()` and `Math.Min()` are methods. 

Each method has a different behavior: The first method prints something to the console, and the second finds the smallest of two given numbers. We activate a method's behavior by _calling_ it. In C# we do this by adding parentheses to the end of a method name.
```cs
Console.WriteLine();
```
Some methods accept inputs called _arguments_. `Console.WriteLine()` accepts one string argument. That argument will be printed to the console.
```cs
// This prints "I'm hungry!"
Console.WriteLine("I'm hungry!"); 
```
Other methods accept multiple arguments, like `Math.Min()`. It expects two number inputs.
```cs
Math.Min(3, 5);
```


You've probably seen built-in methods for each data type too. Every string has access to methods like `IndexOf()` and `Substring()`.
```cs
string name = "beatrice";
name.Substring(0, 3); // returns "bea"
```


 Call a Method

Up until now, you've been calling built-in methods: methods that are available whenever you use C#. Sometimes you need a custom method for your specific program. In that case, you'll need to define your own! 


The basic structure of a method definition looks like this:
```cs
static void YourMethodName()
{
}
```
We'll skip over `static` and `void` for the moment.

In C#, it's convention to use PascalCase to name your method. The name starts with an uppercase letter and each word following begins with an uppercase as well. It's not required in C#, but it makes your code easier to read for other developers.
 
The body of your method goes between the curly braces: `{ }`. Whenever the method is called, the code in the body is executed.
```cs
static void YourMethodName()
{
  Console.WriteLine("Hi there!");
}
```
Just like any other method, we call it with parentheses:
```cs
YourMethodName();
```
Look closely at the code in the editor and you'll see that you've been defining methods all along! `Main()` is a method. Every time you run the code, the `Main()` method is executed.

Since `Main()` is already a method, we'll define our own methods outside of `Main()`.


Define a Method

You learned a lot this lesson: congrats on finishing! Here's what you've covered:
* Call a method with its name and parentheses:
```cs
VisitPlanets();
```
* Store a method's returned value in a variable:
```cs
double result = Math.Round(3.14159, 2);
```
* Define a basic method with the following syntax:
```cs
static void VisitPlanets()
{
}
```
* Every time an application is started, the `Main()` method is called.
* Values passed to a method are called _arguments_. When defined in the method, they are _parameters_.
* Method parameters can only be used within the method body.
* Method parameters can be _optional_ if given a default value using equals `=` syntax:
```cs
static void VisitPlanets(int numberOfPlanets = 0)
```
* When calling a method, pass arguments by position or by name. If using names, use the colon (`:`) syntax:
```cs
VisitPlanets(numberOfPlanets: 9);
```
* In _method overloading_, multiple methods can have the same name, as long as they have different method _signatures_.
* A method _signature_ is a method's name and parameter types in order.




Review

To make our functions even more flexible, we can make certain parameters _optional_. If someone calls your method without all the parameters, the method will assign a default value to those missing parameters.

All you have to do is use the equals sign (`=`) when defining the method. In this example, `punctuation` is an optional parameter, and its default value is `"."`.

```cs
static void Main(string[] args)
{
  YourMethodName("I'm hungry", "!"); // prints "I'm hungry!"
  YourMethodName("I'm hungry");  // prints "I'm hungry."
}

static void YourMethodName(string message, string punctuation = ".")
{
  Console.WriteLine(message + punctuation);
}

```

Optional Parameters

Like a math function or a factory machine, a method takes input and _returns_ output. We've just seen how input works (arguments). Let's see how output works.

When a method _returns_ a value, it essentially passes a piece of data to wherever it was called. One way to capture the returned value of a method is with a variable:
```cs
int smallerNumber = Math.Min(3, 4);
```
`Math.Min()` returns the value `3`, so you can imagine that value taking its place. 

```cs
int smallerNumber = 3;
```

We can then use that variable as input to other methods, like `Console.WriteLine()`:
```cs
Console.WriteLine(smallerNumber);
```
In this case, we can take a shortcut by nesting the method calls:
```cs
Console.WriteLine(Math.Min(3, 4));
```
Now the value returned by `Math.Min()` is used as input to `Console.WriteLine()`.

Not every method returns a value. `Console.WriteLine()`, for example, prints `3` to the console but it doesn't pass the value `3` to its caller. If you're not sure what a method returns you can always [check the Microsoft documentation](https://docs.microsoft.com/en-us/dotnet/api/system.math.min).


Capture Output

Say you want to use `Math.Round()`, a built-in method. You go to the [Microsoft documentation](https://docs.microsoft.com/en-us/dotnet/api/system.math.round) to learn how to use it, and find at least 8 different versions! They all have the same name: `Math.Round()`.

What's happening here is called _method overloading_, and each "version" is called an _overload_. Though they have the same name, the _overloads_ are different because they have either (i) different parameter types or (ii) different number of parameters. This is useful if you want the same method to have different behavior based on its inputs.

Let's examine this concept with these two overloads: `Math.Round(Double, Int32)` and `Math.Round(Double)`. 


The first overload, `Math.Round(Double, Int32)`, rounds the `double` to the `int`'s number of decimal points
```cs
Math.Round(3.14159, 2); // returns 3.14
```

The second, `Math.Round(Double)`, rounds the `double` to the nearest integer.
```cs
Math.Round(3.14159); // returns 3
```

In C#, when we say that the methods are "different", we are really talking about their method _signatures_, which is the method's name and parameter types in order.

For example, both methods above are named `Round()`, but one has `Double` and `Int32` parameters, and the other has a `Double` parameter.


 Method Overloading

One thing to watch for with parameters: they can only be used inside their method!
```cs
static void YourMethodName(string message)
{
  Console.WriteLine(message);
}
Console.WriteLine(message); // causes an error!
```
You'll see an error like...
```
error CS0103: The name 'message' does not exist in the current context 
```
When talking to other developers about this type of issue, you might hear the term _scope_. While the entire concept of scope won't be covered in this lesson, you should know how it applies here: a parameter's scope is within its method, which means that the name (`message` in this case) is only valid within its method. If the parameter name is used outside the method, it has no meaning, so it throws an error.

A Note on Parameters

Remember calling methods with arguments, like `Math.Min(3, 4)`? Methods that you define can use arguments as well, making them more versatile and useful.

While we are defining our method, we don't know the actual argument values that will be used when calling the method. But we do know the expected data type and how it will be used. We can use this information to define a _parameter_, which sort of works like a variable within a method. Imagine it as a placeholder for the actual argument value.

```cs
static void YourMethodName(string identity)
{
  Console.WriteLine(identity);
}
```

The `YourMethodName()` method now has one parameter named `identity` of type `string`.

Separate multiple parameters with commas:
```cs
static void YourMethodName(string identity, int age)
{
  Console.WriteLine($"{identity} is {age} years old.");
}
```
When you call your method, the values to be used for each parameter are called _arguments_. In this case `"Yoda"` and `900` are arguments for the `identity` and `age` parameters.

```cs
YourMethodName("Yoda", 900);
```

Define Parameters

Imagine making a hamburger:

1. Place the bread down
2. Add the burger patty
3. Add the pickles
4. Place the bread on top

What if you had to say each step every time you ordered a hamburger? It’s tedious. It takes a long time. (How do you fit that on a menu?) And it risks making mistakes.

In this lesson you will learn a solution to that problem: _methods_. A method is a reusable set of instructions that perform a specific task. Developers use methods to make their code organized, maintainable, and repeatable. 

You might hear methods also called functions &mdash; for now, the difference isn't important to us.


By the end of this lesson you will be able to recognize methods, call them with multiple arguments, capture their returned values, and define a basic method.



Introduction to Methods

Say your method has lots of optional parameters, but you only want to specify one when you call it. 

In this example, your method has five optional parameters:
```cs
static void YourMethodName(int a = 0, int b = 0, int c = 0, int d = 0, int e = 0) {...}
```
When you call the method, you only want to specify `d`. But calling the method this way would set `a` to `4`, not `d`!
```cs
YourMethodName(4);
```

Refer to the parameter by its name instead:
```cs
YourMethodName(d: 4);
```

With named arguments, you can list them in any order:
```cs
YourMethodName(d: 4, b: 1, a: 2);
```
You can also mix named arguments with positional arguments, but positional arguments MUST come before named arguments:
```cs
YourMethodName(2, 1, d: 4) // a is 2, b is 1, d is 4
YourMethodName(d: 4, 2, 1) // Error!
```

Named arguments aren't always necessary, but they can be useful when:
* a method has many optional parameters
* you want to differentiate between similar arguments
