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 about how to use different loops in C#. 

Loops

Well done! In C#, loops are commonly used because they save time, reduce errors, and are easy to read. Being comfortable with each type of loop will make you a better programmer. In review:
- A _loop_ is a structure in programming where the instructions are written once, but a computer can execute them multiple times
- Each execution of those instructions is called an _iteration_
- `while` loops repeat until a condition changes
- `do...while` loops execute once, and then repeat until a condition changes
- `for` loops repeat for a specified number of times
- `foreach` loops repeat for each item in a collection
- _jump statements_, like `break`, `continue`, and `return` are used to add additional control flow to loops

Now that you know a few things about loops, try writing a program that:
- Loops through a piece of text and only prints words that start with the letter "a" to the console to create a poem.
- Loops through a list of numbers and if it is even, print even and if it's odd, print odd.
- A Choose Your Own Adventure game that uses a while loop to make sure a user chooses a correct option. 


Review

Imagine you're building a video game and in this game, you want to add 15 aliens to the screen.

How do we use code to tell a computer this: “Create a variable and call the method 15 times”?

We could write it out 15 times:

```csharp
AddAlien();
AddAlien();
AddAlien();
AddAlien();
...
```

…We’ll spare you the rest. This approach takes a long time and it can easily lead to mistakes. Instead, let’s give the instructions once and tell the computer how many times to repeat them:

```
for (int i = 0; i < 15; i++)
{
  AddAlien();
}
```

_Loops_ are structures that we can use to repeat instructions until a certain condition is met. That condition could be a change in state ("keep playing music until 10pm"), an end of a list ("say each name out loud"), or a number ("knock three times"). 

When we see repetition in our code, it's a good sign that we should probably use a loop. By not writing out instructions multiple times, we reduce our chance for errors and save ourselves some time. 

There are several kinds of loops that we can use depending on the situation. This lesson will cover:
- `while` loops
- `do...while` loops
- `for` loops
- `foreach` loops



Introduction to Loops

What if we want our code to execute a specific number of times? We can use a `for` loop to do that. 

```
for (initialization; stopping condition; iteration statement)
{
  statement;
}
```

The `for` loop tells the computer how many times to repeat the instructions using the `for` keyword and three expressions inside of parentheses. Each of these expressions use what's known as an `iterator` variable, which is a variable that keeps track of how many times the program goes through the loop. 

These expressions are:
- _Initialization_: where the loop begins 
- _Stopping condition_: the condition that the iterator variable is evaluated against 
- _Iteration statement_: used to update the iterator variable on each loop

The `for` loop is good to use when you know the number of times you’d like to perform a task before you begin, like printing three copies of a document or inserting eight rows into a table. 

In our video game, we want ten flags to appear at the start of each level:

```csharp
for (int i = 0; i < 10; i++)
{
  DisplayFlag();
}
```

When a computer receives this program it sets a counter to `0` and executes the instructions in the body of the loop, which in this case instructs the computer to display a flag. After each iteration, or one turn through the loop, the program advances the counter by one (`i++`). The process repeats until the counter reaches `10`, meaning ten iterations are completed and there are ten flags on the screen.


For Loop

There’s one more way to give looping instructions to a computer. We define a sequence of values and tell the computer to repeat the instructions for each item in the sequence. 

```
foreach (type element in sequence)
{
  statement;
}
```

The `foreach` loop is used to iterate over collections, such as an array. 

In our video game, we want to play a melody. We can do that by iterating through a list of individual notes, playing one after the other. Here’s an example array of notes:

```csharp
string[] melody = { "a", "b", "c", "c", "b" };
```

and the loop would look like:

```csharp
foreach (string note in melody)
{
  PlayMusic(note);
}
```

The sequence we used was an array, but we can use other similar data structures. The umbrella term for those is collection, so we can also call `foreach` loops _collection loops_.

Use this loop when you need to perform a task for every item in a list, or when the order of things must be maintained. In this case, both are important. A note must be placed for each item in the list and the order of them is essential to the musical pattern.


For Each Loop

Loops are used to repeat a set of instructions based on a set of conditions. If this makes you think of conditional statements, you're not wrong! 

The `while` loop looks very similar to an `if` statement. Just like an `if` statement, it executes the code inside of it if the condition, a statement that evaluates to a boolean value, is true.

```
while (condition) 
{
  statement;
}
```

However, unlike an `if` statement that runs once, a `while` loop will continue to execute the code inside of it, over and over again, _while_ the condition is true. The computer is constantly checking to see if the condition is satisfied. For this reason, `while` loops are useful when you know at what point a program should stop, rather than the number of times it should repeat. 

In your video game, you want the player to rise up in the air as long as the user is pressing the spacebar:

```csharp
while (spacebar == "down") 
{
 RiseUp();
}
```

In this example, while `spacebar` is equal to `down`, the character will keep rising on the screen. It will exit the `while` loop once the user releases the spacebar and then the rest of the program will continue. 

`while` loops can get dangerous, because they depend on that condition to at some point return false. What if we never take our finger off the spacebar? Sounds ridiculous, but theoretically, the program would run forever! This is known as an _infinite loop_. If you get stuck in an infinite loop while on Codecademy, you can reload the page to stop it.


While Loop

There are a few keywords we can use to add further control flow to our loops. Typically, they work with a series of _nested loops_, where one loop is written entirely within the body of another loop. These keywords are often used to limit `while` loops and prevent them from creating infinite loops.

#### BREAK
At any point within a loop block, you can end it by using the `break` keyword. 

```csharp
while (playerIsAlive) 
{ 
// this code will keep running

  if (playerIsAlive == false) 
  { 
    // eventually if this stopping condition is true, 
    // it will break out of the while loop
    break; 
   } 
 } 

// rest of the program will continue
```

You've already seen the `break` keyword&mdash; it's the same keyword that is used in switch statements. 


#### CONTINUE

The `continue` keyword is used to bypass portions of code. It will ignore whatever comes after it in the loop and then will go back to the top and start the loop again. 

```csharp
int bats = 10;

for (int i = 0; i <= 10; i++)
{
  if (i < 9)
  {  
    continue;
  }
  // this will be skipped until i is no longer less than 9
  Console.WriteLine(i);
}
```

Here, the program starts in the `for` loop, then hits the `if` statement. Since there is a `continue` in the `if` statement, it will bypass the `Console.WriteLine()` statement until the condition in the `if` statement is no longer true. So while the loop starts at 0, nothing will print to the console until `i` is equal to 9.


#### RETURN
The `return` keyword is another way to exit a loop, specifically loops that are used within a method. When a `return` is used within such a loop, it breaks out of the loop and returns control to the point in the program where the method was called. 

```csharp
class MainClass {
 public static void Main (string[] args) {
   UnlockDoor();

  // after it hits the return statement, it will move on to this method
   PickUpSword();
 }

 static bool UnlockDoor()
 {
   bool doorIsLocked = true;

   // this code will keep running
   while (doorIsLocked)
   {
     bool keyFound = TryKey();

      // eventually if this stopping condition is true,
      // it will break out of the while loop
     if (keyFound)
     {
      // this return statement will break out of the entire method
      return true;
     }
   }
   return false;
 }
}
```

You should only use `return` if you need to exit a method because it will break out of *all* loops. If you only want to break out of one loop and not exit a method, use `break`. 


Jump Statements

You may have noticed that there are lots of similarities between different types of loops, and you're right! 

We just showed how we can use a `foreach` loop to iterate through an array. But we can also use a `for` loop to iterate through an array: 

```csharp
string[] items = { "potion", "dagger", "shield", "plant" };

for (int i = 0; i < items.Length; i++)
{
  Console.WriteLine(items[i]);
}
```

We could even write a complicated `while` loop that starts a counter at 0, then compares that counter to the length of the `items` array. If the counter is less than the array, the loop will continue. Otherwise, it will stop looping through the statements and the program will move on to the next line of code. 

```csharp
int i = 0;
while (i < items.Length)
{ 
  Console.WriteLine(items[i]); 
  i++; 
}
```

Since a `foreach` loop does the same thing as the other two but is more concise, it is less prone to errors and the better choice in this circumstance. 

```csharp
string[] items = { "potion", "dagger", "shield", "plant" };

foreach (string item in items)
{
  Console.WriteLine(item);
}
```

In general, 

- `while` loops are good when you know your stopping condition, but not when you know how many times you want a program to loop or if you have a specific collection to loop through. 
- `do...while` loops are only necessary if you definitely want something to run once, but then stop if a condition is met. 
- `for` loops are best if you want something to run a specific number of times, rather than given a certain condition.
- `foreach` loops are the best way to loop over an array, or any other collection. 



Comparing Loops

Similar to the `while` loop, a `do...while` loop will continue running until a stopping condition is met. One key difference is that no matter what, a `do...while` loop will *always run once*. 

```
do
{
  statement;
} while (condition);
```
Instead of checking the condition before the code block executes, the program in the block runs once and _then_ checks the conditional statement. It will either stop or continue to execute until the condition is no longer true. `do...while` loops are good for when a program should execute at least once and then depending on the circumstances, continue to execute or stop. 

In your video game, you want to show the start screen for at least one frame. If the user does not hit next, you want the start screen to continue to appear until they do so. 

```csharp
bool startGame = false;

do
{
  ShowStartScreen();
} while (!startGame);
```

In this example, we initialize a Boolean value `startGame` to the state `false`. The program runs once, showing the start screen for one frame, then checks to see if the player has started the game. If the player has yet to start the game, it will call `ShowStartScreen()` again and will then continue to show the start screen until the player presses start.
