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 how to use conditional and switch statements to add logic to programs. 

Conditional Statements

Conditional statements are the most commonly used control structures in programming. They rely on the computer being able to reason whether conditions are true or false. 

The most basic conditional statement is an _if statement_. An _if statement_ executes a block of code if specified condition is true.

In C#, we write an if statement using the following syntax:
```csharp
string color = "blue";

if (color == "blue")
{
  // this code block will execute only if the value of color is 
  // equivalent to "blue"
  Console.WriteLine("color is blue");
}
```
In this example, our if conditional statement checks to see if the value of the variable `color` is equivalent to the string `"blue"`. Since it is, it will execute the code in the code block and print the string `"color is blue"` to the console. If color equals another value or was null, the program skips over the block and moves on to the next instruction. 

When writing an if statement, make sure to pay attention to:
- Parentheses: we place the boolean expression that the if statement is evaluating in parentheses `()`.
- Braces: after the boolean expression, we write a set of braces `{}`. Write the code that will execute if the boolean expression evaluates to true inside these braces.
- Indentation: while whitespace won't impact our program, it is convention to indent the code inside the braces by two spaces. 

If Statements

What if we want to handle multiple conditions and have a different thing happen each time? Conditional statements can be chained by combining `if` and `else` statements into `else if`. After an initial if statement, one or more `else if` blocks can check additional conditions. An optional `else` block can be added at the end to catch cases that do not match any of the conditions.

In C#, we write an `if..else if...` statement using the following syntax:
```csharp
string color = "red";

if (color == "blue")
{
  // this code block will execute only if the value of color is 
  // equivalent to "blue"
  Console.WriteLine("color is blue");
} 
else if (color == "red")
{
  // this code block will execute if the value of color is 
  // equivalent to "red"
  Console.WriteLine("color is NOT blue");
} 
else // this is optional
{
  // this code block will execute if the value of color is 
  // NOT equivalent to "blue" OR "red"
  Console.WriteLine("color is NOT blue OR red");
}
```
In this example, the program checks to see if `color` equals `"blue"` OR `"red"`. Depending on what `color` is equivalent to, it will execute the corresponding code block. If it isn't equal to either of those colors, it will execute the `else` block before moving on with the rest of the program. 

When using else if statement, make sure to pay attention to:
- Each `else if` statement gets its own condition: make sure to specify the condition an else if is evaluating. Just like an `if` statement, this condition goes in parentheses and if true, will execute what is in the code block. 
- `else` follows `else if`: If you choose to include an else statement (it's optional), make sure it comes after any else if statements you might have.


Else If Statements

The _ternary operator_ allows for a compact syntax in the case of binary decisions. Like an `if...else` statement, it evaluates a single condition and executes one expression if the condition is true and the second expression otherwise.

Here's an example of a ternary operator in action:

```csharp
string color = "blue";
string result = (color == "blue") ? "blue" : "NOT blue";

Console.WriteLine(result);
```
In this example, we create a variable `result` and save the outcome of the ternary operator expression. The expression starts with the Boolean expressions `(color == "blue")`, followed by the ternary operator `?`, then the two possible outcomes, separated by a colon `:`. The first outcome, `"blue"` will be saved to `result` if the Boolean expression evaluates to `true`, otherwise it will store the second outcome. 

Ternary operators can also be chained, like else if statements. But careful! Since the entire expression exists on one line, it can quickly become unreadable. 

When using ternary operators, make sure to pay attention to:
- Parentheses: we place the boolean expression that the statement is evaluating in parentheses `()`.
- The `?` operator: make sure this comes after the statement and before the outcomes.
- Colon: This separates the two possible outcomes. 


Ternary Operators

Great job! You just learned about how to create programs that use control flow. Here's a few of the things we covered:
- Using `if`, `else if`, and `else` keywords to write conditional statements
- Writing switch statements for situations where they are many conditions
- Using ternary operators for shorter conditional statements

Now that you know a few things about control flow, try writing a program that:
- Has a user guess a random number between 1-10 and lets them know if they got it correct, are too low, or are too high
- Asks users to select their favorite fast food and tells them what type of cat they are (or basically, any kind of Buzzfeed style quiz)
- Checks if it's your birthday. If it is, it will print out a celebratory ASCII banner and if not, it will tell you how many days until your birthday. 


Review

We make decisions all the time in our life based on different conditions. Are you going to drink tea or coffee? Study history or biology? Buy a new shirt or save your money? 

We can program computers to make decisions based on different conditions. We can specify to the computer the _order_ in which it should execute certain instructions, or that it should only execute _certain_ instructions in specific cases. That means that depending on the conditions, the instructions that our program executes can change. 

The order that computer programs execute a set of instructions is known as _control flow_. We can use different _control structures_ to alter the flow of our program. Control structures let us handle different situations that might arise and make our programs more flexible. In C#, these type of statements are known as conditional or [selection statements](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/selection-statements). 

Boolean logic and conditional statements go hand in hand. A computer will determine if a condition is true or false and execute a set of instructions accordingly. Make sure that you're comfortable with Boolean values, comparison operators, and logical operators!

We'll look at a couple of different structures that use Boolean logic to control the flow of our programs, including:
- If statements
- If...Else… statements
- Else if statements
- Switch statements
- Ternary Operators


Introduction to Conditional Statements

What if we want another set of instructions to execute if the condition is false? An `else` clause can be added to an `if` statement to provide code that will only be executed if the `if` condition is false. 

In C#, we write an if..else... statement using the following syntax:
```csharp
string color = "red";

if (color == "blue")
{
  // this code block will execute only if the value of color is 
  // equivalent to "blue"
  Console.WriteLine("color is blue");
} 
else 
{
  // this code block will execute if the value of color is 
  // NOT equivalent to "blue"
  Console.WriteLine("color is NOT blue");
}
```
In this example, we're still checking to see if `color` equals `"blue"`. However, this time we also added a second code block that will execute if the result of `(color == "blue")` is false. Since `color` equals `"red"` this time, it will skip the first code block and execute the second code block, before moving on with the rest of the program. 

When writing an if...else... statement, make sure to pay attention to:
- `else` follows `if`: In an if...else… statement, the `else` statement and its corresponding code block still need to follow the `if` statement and code block.
- Number of code blocks: Make sure that if you include an `else` statement, that you include a code block with it.

If...Else... Statements

Using multiple `else if` statements can get unwieldy pretty quickly. Imagine writing an `else if` statement for every possible number of guests. And you invited 20 people. You have to write a lot of repetitive code, which is hard to read and prone to errors.

If it's necessary to evaluate several conditions with their own unique output, a _switch statement_ is the way to go. Switch statements allow for compact control flow structures by evaluating a single expression and executing code blocks based on a matched case.

In C#, we write a switch statement using the following syntax:

```csharp
string color;

switch (color)
{
   case "blue":
      // execute if the value of color is "blue"
      Console.WriteLine("color is blue");
      break;
   case "red":
      // execute if the value of color is "red"
      Console.WriteLine("color is red");
      break;
   case "green":
      // execute if the value of color is "green"
      Console.WriteLine("color is green");
      break;
   default:
      // execute if none of the above conditions are met
      break;
}
```
In this example, the program checks to see what the value of `color` equals. If it matches any of the specified cases, it will execute the code associated with that case. In C#, the  _break_ keyword allows programs to exit a block when a specific condition is met. If none of the conditions are met, the code inside the `default` case will run.

When using a switch statement, make sure to pay attention to:
- Cases: rather than writing out each condition, if we're evaluating one value we use _cases_ to specify different potential values.
- Braces: rather than each case having its own code block, the entire statement lives within one set of braces `{}`. 
- Colons: to distinguish between different cases, we state the case value, followed by a colon `:`.  The code that should execute if that case is met follows.
- Break: Each case code needs to end with a `break` keyword. 
- Default: Every switch statement needs a `default` case. 
