How to Build a Game & Learn C#: User Input & If Statements
Tags: csharp, dotnet, tutorial, beginners
Published: 2021-02-23 14:35:30

In our last two tutorials we discussed creating a new C# project and the concepts of variables and expressions as we moved towards programming our first application: a Guess the Number Game. 

In this tutorial, we'll expand our bag of tools to get text from the user, interpret it as a number and perform some basic mathematics with it. We'll close by introducing *if statements*, an extremely powerful tool in our toolbelts as programmers.

This article is also available in video form:

{% youtube Xz3VASJXyeQ %}

_Note: This series is based loosely on some of the content from the 1st week of [Tech Elevator](https://www.TechElevator.com?utm_campaign=Homepage_Traffic&utm_medium=Homepage%20Referral&utm_source=GuessTheNumberCSharp)'s 14 week C# curriculum_

Let's get started.

# Cleaning the Slate

In our last article we wrote some basic code to illustrate `string` and `int` variables. That was good as a learning exercise, but it won't be useful for our final application, a game where the user can guess a number from one to one hundred and be told if their guess was high, low, or correct.

Let's clear out the existing `Main` method and replace it with this:

```cs
static void Main(string[] args)
{
    // The program's secret number that the player has to guess
    int secretNumber = 42; // TODO: This should be random between 1 - 100
    int guess = 0;
            
    // TODO: Let the player enter a number

    // TODO: Evaluate the player's guess and respond

    // TODO: Loop until the player gets the answer right

    // After this line is reached, the program will end
}
```

Here we have a mostly empty method that has major comments for the logic we'll need to do in this tutorial and the next one in order to get the game working properly.

We also have a `secretNumber` integer variable that is set to `42` for now, but we'll have the program generate a random number next tutorial. 

This `secretNumber` represents the number that the player has to guess. By the end of this tutorial, you'll be able to enter a number into the console and be told if it is less than, greater than, or exactly the "secret" number.

_Note: We're declaring our `guess` variable here to save us some time and confusion later on. Don't worry about why this line is here yet._

# Getting User Input

Let's expand the `// Let the player enter a number` comment to include the following code:

```cs
// Let the player enter a number
Console.WriteLine("What is your guess?");
string guessText = Console.ReadLine();

Console.WriteLine("You guessed: " + guessText);
```

Before we talk about the code, let's run the program with these changes. You should now be able to enter some text and see the result in the console as shown below:

![Enter Your Guess](https://dev-to-uploads.s3.amazonaws.com/i/cfbm7wswnhrq0rtvrsnh.png)

This works because `Console.ReadLine()` causes the program to wait for the user to type in some text and type enter. The program then takes that value and assigns it into the `guessText` variable.

So, if the user typed in "I'm Batman" (remember, `ReadLine` allows the user to type in _any_ text), `guessText` would store that string and the following line: `Console.WriteLine("You guessed: " + guessText);` would evaluate to `Console.WriteLine("You guessed: I'm Batman");` and display that message.

Next, let's look at how we can interpret the user's input as a number.

# Parsing Strings to Integers

While we can't change `Console.ReadLine` to have it return an `int` instead of a `string` or require a numeric input, we _can_ try to interpret the string the user typed in as a number.

We do this via the `int.Parse` method.

Add the following code below the code you wrote earlier:

```cs
guess = int.Parse(guessText);

Console.WriteLine("2 x " + guess + " = " + (guess * 2));
```

There's a decent amount going on here, so let's take it a line at a time.

`guess = int.Parse(guessText);` sets the `guess` variable we declared earlier to be the result of `int.Parse` on the user's text. `int.Parse` is a method provided by .NET's base class libraries that takes in a `string` and attempts to convert it to an integer.

_Note: There are ways of handling cases where the user types in random text instead of something that is a number. However, for the purposes of keeping this tutorial focused, we'll assume that the user is providing valid input_

# Revisiting Expressions

Next let's talk about that `Console.WriteLine("2 x " + guess + " = " + (guess * 2));` line.

This is similar to what we've seen before, but a bit more complicated. We have a few new things that we've not seen before in the `(guess * 2)` expression.

The `*` operator means multiplication, so this will multiply the current value of `guess` by `2`.

When this line runs and `guess` is 5, it will first evaluate to

```cs
Console.WriteLine("2 x " + 5 + " = " + (5 * 2));
```

This simplifies down to

```cs
Console.WriteLine("2 x " + 5 + " = " + 10);
```

This is a lot more familiar and simplifies to

```cs
Console.WriteLine("2 x 5 = 10");
```

Which is exactly what is displayed on the screen.

![App displaying 2 x 5 = 10](https://dev-to-uploads.s3.amazonaws.com/i/ql4v7kdo7mc1lwrbc6e3.png)

# Getting Ready for Conditions

Okay, now that we've demonstrated that integer parsing works, let's remove the last two `Console.WriteLine` statements. Your code should now look like this:

```cs
static void Main(string[] args)
{
    // The program's secret number that the player has to guess
    int secretNumber = 42; // TODO: This should be random between 1 - 100
    int guess = 0;

    // Let the player enter a number
    Console.WriteLine("What is your guess?");
    string guessText = Console.ReadLine();

    // TODO: Evaluate the player's guess and respond
    guess = int.Parse(guessText);

    // TODO: Loop until the player gets the answer right

    // After this line is reached, the program will end
}
```

We should now be in a good place to start looking at interpreting the user's guess.

# If Statements

Now, let's look at some new syntax for conditionally doing things in code: the _if statement_.

If statements let us do specific logic if an expression evaluates to `true`.

Below the `int guess = ...` line, add the following code:

```cs
if (guess == secretNumber)
{
    Console.WriteLine("You guessed the secret number!");

    Console.WriteLine("The application will now close.");
}
```

Now when we run the application, if you type in "42" you should see the console message indicating you guessed the number:

![Correct Guess](https://dev-to-uploads.s3.amazonaws.com/i/lbsxcud7nyeo1x4agd4d.png)

So let's look at how this works. We'll start at that first line: `if (guess == secretNumber)`

The _if_ statement requires parentheses. Inside these parentheses, C# needs an expression that evaluates to either `true` or `false`. If the expression evaluates to `true`, any code inside of the `{ }`'s will be executed. 

The code inside the `{}`'s can be any C# code you can write - variable declarations, Console calls, etc. The key here is that it _only_ is executed if the expression in the if statement is `true`.

Let's look a bit more at that expression: `guess == secretNumber`. We've not seen `==` before. The "double equals" operator is a way to compare the left side to the right side. If the two sides are equal, the expression will evaluate to `true`, otherwise the expression will evaluate to `false`.

As an example, if the current value of `guess` is 35, the line becomes `if (35 == 42)` which evaluates to `if (false)`. Since this value is `false`, the code inside the `{ }`'s will _not_ execute.

Conversely, if `guess` was 42, the line becomes `if (42 == 42)` or `if (true)` and the code inside the `{}`'s _will_ work.

# If / Else Blocks

So, if statements are powerful, but they can do a bit more than we just did. We can add an `else` statement after our `if` as shown below:

```cs
if (guess == secretNumber)
{
    Console.WriteLine("You guessed the secret number!");

    Console.WriteLine("The application will now close.");
}
else
{
    Console.WriteLine("Nope. That wasn't the number.");
}
```

Here one of these two `{ }` _blocks_ will always be executed. If the expression in the `if` statement is `true`, the first block will execute as before. Otherwise, the `else` block will execute and the user will see the message indicating that they guessed incorrectly.

# Chaining If / Else Blocks

But wait, there's more!

Remember that the app we're building will tell the user if their guess was exactly correct, too high, or too low. Right now we only give the user information on whether their guess was correct or incorrect.

We can take advantage of else blocks to _chain_ together if statements by replacing that second `{ }` (and its code) with another if statement as shown below:

```cs
if (guess == secretNumber)
{
    Console.WriteLine("You guessed the secret number!");

    Console.WriteLine("The application will now close.");
}
else if (guess > secretNumber)
{
    Console.WriteLine("The number is lower than " + guess);
}
```

Here we go directly from the `else` statement into another if statement. This is entirely legal C# code and will only execute if the guess is _not_ the secretNumber.

C# will then evaluate that second if statement and check `if (guess > secretNumber)`. 

We haven't looked at `>` before, but this is a comparison operator that evaluates to `true` if the left side is greater than the right side and false otherwise. Similarly, there is also a `<` operator for less than as well as `>=` and `<=` for greater than or equal to and less than or equal to.

Now, if we run and guess 50, we'll see a message indicating that our guess was too high.

![Guess too high](https://dev-to-uploads.s3.amazonaws.com/i/wj67350lmlyss3xmsupf.png)

# Accounting for All Possibilities

Our code is still missing something, however. If the user guesses a number _below_ the secret number, they won't see a message. Let's add an `else` to the end of our logic as shown below:

```cs
// Evaluate the player's guess and respond
guess = int.Parse(guessText);
if (guess == secretNumber)
{
    Console.WriteLine("You guessed the secret number!");

    Console.WriteLine("The application will now close.");
}
else if (guess > secretNumber)
{
    Console.WriteLine("The number is lower than " + guess);
} 
else // If we got here guess must be < secretNumber
{
    Console.WriteLine("The number is greater than " + guess);
}
```

This finalized if / else chain handles cases where:

- `guess` is exactly equal to `secretNumber`
- `guess` is greater than `secretNumber`
- All other cases (less than `secretNumber`)

Now, no matter what the user enters, they should see a message letting them know how close their guess was.

# Next Steps

As you can see, we're starting to get to a workable application, but we're still missing a few key pieces.

In the final tutorial of the series, we'll introduce random number generation, loops, and tie everything together into a single application.

This article is based on abridged content from a few days in the first week of [Tech Elevator's](https://www.TechElevator.com?utm_campaign=Homepage_Traffic&utm_medium=Homepage%20Referral&utm_source=GuessTheNumberCSharp) 14 week full stack C# development curriculum. Learn more about Tech Elevator, [take a free aptitude test](https://www.techelevator.com/aptitude-test?utm_campaign=Get%20Started_Traffic&utm_medium=Get%20Started%20Page&utm_source=GuessTheNumberCSharp) to see if you might be a good match for development, or check out our other [Learn to Code resources](https://www.techelevator.com/learn-to-code-resources)