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)


Define methods with output and recognize and resolve errors related to method output


Method Output

The basic way to _return_ values from a method is to use a `return` statement! (A well-constructed programming language shouldn't have a lot of surprises.)

Let's start with an example in the below code. It contains a definition of the `Yell()` method, which returns a string, and it calls that method in `Main()`.

When we execute this program, the code in `Main()` runs first:
1. `Yell()` is called.
2. In `Yell()`, the uppercase version of `"who's there?"` is created and returned. 
3. Back in `Main()`, that returned value is stored in the variable `output` and then printed to the console:

```cs
static string Yell(string phrase) 
{
  return phrase.ToUpper();
}

public static void Main()
{
  string output = Yell("who's there?");
  Console.WriteLine(output); // Prints WHO'S THERE?
}
```

Here's a more generic definition: the keyword `return` tells the computer to exit the method and return a value to wherever the method was called.

When a method is declared, it must announce the type of value it will return. In this case, `Yell()` returns a string, so it has the `string` modifier (right before the name `Yell`).

That first line of the method is called a _method declaration_, so we can say that the method declaration must contain the type of the return value.

Generally, the method declaration is a combination of details including: the access modifiers, return type, method name, and parameter types. This lesson will not cover access modifiers, like `static`, so that we can focus on the return type, like `string`.



Return

As with `return`, `out` is a very useful keyword, but it can lead to errors if used incorrectly. Here are two common ones:

This error means that the `out` parameter needs to be assigned a value within the method:
```
error CS0177: The out parameter 'success' must be assigned to before control leaves the current method
```

This error means you called a method that expects an 'out' parameter but you didn't use the `out` keyword when calling it:
```
error CS1620: Argument 2 must be passed with the 'out' keyword
```

Out Errors

What's the outcome of calling a method?

Sometimes a message is printed to the console:
```cs
Console.WriteLine("Hello World!");
```
Sometimes a value is returned:
```cs
Math.Floor(15.6); // Returns 15
```
Sometimes a variable is altered:
```cs
int number;
bool success = Int32.TryParse("10602", out number); 
// number is 10602 and success is True
```

If you don't understand all of the code examples, that's okay! By the end of this lesson you will be able to:
* Define methods with output using the `return` and `out` keywords
* Recognize and resolve errors related to method output

Let's get started!

Introduction to Method Output

Congrats on finishing! You can now use and define methods with output.

Here's what else you've learned in this lesson:
* Methods return values with the `return` keyword.
* Every method has a return type, designated in its method signature. That type must match the type of the value actually returned.
* If a method returns no type, its return type is `void`.
* `out` parameters can be used to return multiple values from a method.

You can always review this material on the [Microsoft documentation](https://docs.microsoft.com/en-us/dotnet/csharp/methods).


Review

A method can only _return_ one value, but sometimes you need to output two pieces of information. Calling a method that uses an `out` parameter is one way to return multiple values.

For example, the `Int32.TryParse()` method tries to parse its input as an integer. If it can properly parse the input, the method returns `true` and sets its `out` variable to the new value.  If it cannot properly parse the input, the method returns `false` and sets the `out` variable to 0.  

This is what the method's signature looks like:

```cs
public static bool TryParse (string s, out int result);
```

The method returns a `boolean` and accepts a `string` and a variable that has been declared of type `int` as input.


Here's how `Int32.TryParse()` and the `out` parameter are used:
```cs
int number;
bool success = Int32.TryParse("10602", out number); 
// number is 10602 and success is true
int number2;
bool success2 = Int32.TryParse(" !!! ", out number2);
// number2 is 0 and success2 is false
```
The second parameter is labeled `out`, which means that it must be assigned a value within the method.

For a shortcut, you can declare the `int` variable within the method call:
```cs
bool success = Int32.TryParse("10602", out int number);
```


As we mentioned before, we don't like surprises &mdash; they lead to mistakes. So, when we call a method, we'd like to know what type of value will be returned. This is done in the method definition.

The method definition must contain the type of the return value: if a method returns an integer, its return type must be `int`; if it returns text, it must be `string`, and so on. If the method returns nothing, use `void`.

If a method returns a type different from its stated return type, it will throw an error. Here are some common errors you may see &mdash;

This error means you must state a return type before the method name:
```
error CS1520: Method must have a return type
```

This error means that your method doesn't return a value, when it should:
```
error CS0161: [MethodName]: not all code paths return a value
```
In some cases, this error means that your method returns a `string` when it should be an `int` (this one can be caused by a lot of things outside of methods):
```
error CS0029: Cannot implicitly convert type 'string' to 'int'
```

It's important to remember that running into errors is a natural part of coding. As a teacher once put it ["Great programmers understand that errors are part of the process, and they know how to find the solution to each while learning something new from them."](https://news.codecademy.com/errors-in-code-think-differently/)

Return Errors

We can use `out` parameters in our own methods as well. In this example, `Yell()` converts `phrase` to uppercase and sets a boolean variable to `true`:

```cs
static string Yell(string phrase, out bool wasYellCalled)
{
  wasYellCalled = true;
  return phrase.ToUpper();
}
```

* The `out` parameter must have the `out` keyword and its expected type
* The `out` parameter must be set to a value before the method ends

When calling the method, don't forget to use the `out` keyword as well:
```cs
string message = "garrrr";
Yell(message, out bool flag);
// returns "GARRRR" and flag is true
```

