Making decisions and repeating actions — the heart of every program.

Think about the last app you used. Maybe you scrolled through a feed, tapped a button, or saw a personalized message. Every one of those actions involved the program asking itself questions: "Is the user logged in?", "Which item did they tap?", "How many times should I repeat this animation?"

Control flow is the mechanism that lets a program make decisions and repeat actions. Without it, a program would just run from top to bottom, line by line, doing the same thing every time — no choices, no loops, no interactivity.

In this lesson, you'll learn the main control flow statements in C#, how they work, and when to use each one. By the end, you'll be able to write code that branches and loops like a real application.

What Is It?

The Simple Explanation

Control flow is the order in which the statements of a program are executed. It includes branching (choosing between different paths) and looping (repeating a block of code).

The Technical Definition

In C#, control flow statements determine the execution path of a program based on conditions and repetition. The main categories are:

• Selection statements — if, else if, else, switch (classic and modern switch expressions).
• Iteration statements — for, foreach, while, do-while.
• Jump statements — break, continue, return, goto (rarely used).
• Exception handling — try, catch, finally, throw (covered separately).

Why Does It Exist?

The Problem

Programs need to respond to different situations. A payment system must process a credit card differently than a PayPal payment. A game must repeat the game loop until the player quits. A web app must show different pages based on the user's role.

Without control flow, you'd have to write a separate program for every possible scenario — impossible and impractical.

The Solution

Control flow statements allow you to express decision logic and repetition directly in code, making programs dynamic and responsive. They are the building blocks of algorithms.

Big Picture

Here's a visual representation of control flow paths in a simple login check:

This simple decision is a perfect example of if-else. Loops would handle repeated tasks, like processing every item in a shopping cart.

How It Works

Let's trace how different control flow statements execute.

Step 1 — if and else

int age = 20;
if (age >= 18)
{
    Console.WriteLine("Adult");
}
else
{
    Console.WriteLine("Minor");
}

The condition age >= 18 is evaluated first. If true, the first block runs; otherwise, the else block runs. Only one branch executes.

Step 2 — else if ladder

int score = 85;
if (score >= 90) Console.WriteLine("A");
else if (score >= 80) Console.WriteLine("B");
else if (score >= 70) Console.WriteLine("C");
else Console.WriteLine("F");

Conditions are checked top to bottom. The first true condition's block executes, and the rest are skipped.

Step 3 — switch statement (classic)

string day = "Monday";
switch (day)
{
    case "Saturday":
    case "Sunday":
        Console.WriteLine("Weekend");
        break;
    case "Monday":
        Console.WriteLine("Start of week");
        break;
    default:
        Console.WriteLine("Weekday");
        break;
}

The switch evaluates day and jumps to the matching case. Multiple cases can share a block. break exits the switch.

Step 4 — switch expression (modern C#)

string dayType = day switch
{
    "Saturday" or "Sunday" => "Weekend",
    "Monday" => "Start of week",
    _ => "Weekday"
};
Console.WriteLine(dayType);

This is a more concise expression form introduced in C# 8. It returns a value and uses pattern matching (or, _ discard).

Step 5 — for loop

for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

Initialization (int i=0) happens once. Condition (i<5) is checked before each iteration. After each body execution, increment (i++) runs. Loop stops when condition is false.

Step 6 — foreach loop

var numbers = new[] { 1, 2, 3, 4, 5 };
foreach (var n in numbers)
{
    Console.WriteLine(n);
}

foreach iterates over each element in a collection. The loop variable is read-only.

Step 7 — while and do-while

int count = 0;
while (count < 3)
{
    Console.WriteLine(count);
    count++;
}

int attempt = 0;
do
{
    Console.WriteLine("Trying...");
    attempt++;
} while (attempt < 3);

while checks condition before each iteration. do-while executes at least once before checking.

Simple Example

Let's write a small program that categorizes a number as positive, negative, or zero, and then prints numbers from 1 to the absolute value of that number.

using System;

int number = -3;

// Branching
if (number > 0)
{
    Console.WriteLine("Positive");
}
else if (number < 0)
{
    Console.WriteLine("Negative");
}
else
{
    Console.WriteLine("Zero");
}

// Looping - using absolute value to avoid negative bounds
int limit = Math.Abs(number);
for (int i = 1; i <= limit; i++)
{
    Console.WriteLine(i);
}

Code → Meaning → Result

• if/else if/else categorizes based on sign.
• Math.Abs ensures loop runs a positive number of times.
• for loop repeats exactly limit times.

Real-World Example

Consider an e-commerce order processing function that iterates through cart items and applies discounts based on membership tier.

using System;
using System.Collections.Generic;

List<(string Name, decimal Price)> cart = new()
{
    ("Laptop", 1200m),
    ("Mouse", 25m),
    ("Keyboard", 75m)
};

string membership = "Gold";
decimal total = 0m;

foreach (var item in cart)
{
    decimal discountPercent = membership switch
    {
        "Platinum" => 0.20m,
        "Gold" => 0.15m,
        "Silver" => 0.10m,
        _ => 0m
    };

    decimal discount = item.Price * discountPercent;
    decimal finalPrice = item.Price - discount;
    total += finalPrice;

    Console.WriteLine($"{item.Name}: {finalPrice:C}");
}

Console.WriteLine($"Total: {total:C}");

This combines foreach for iteration, switch expression for membership-based discount, and arithmetic operators. The loop accumulates the total.

Why not for? Because we don't need index manipulation; foreach is simpler and more readable for collections.

Analogy

Under the Hood

How does the compiler and runtime handle control flow?

Common Confusion

1. else if vs separate if statements

else if is part of a single decision chain: only one branch executes. Separate if statements are independent; multiple can execute.

2. switch statement vs switch expression

• Statement: traditional, uses case, break, can contain statements.
• Expression: introduced in C# 8, returns a value, uses =>, no break needed.

3. for vs foreach

Use for when you need an index or need to skip/increment in custom ways. Use foreach when you just need to access each element.

4. while vs do-while

while may execute zero times; do-while executes at least once.

5. break vs continue

break exits the loop entirely. continue skips the rest of the current iteration and moves to the next condition check.

Common Mistakes

Mistake 1 — Forgetting break in classic switch

Without break, execution falls through to the next case, causing unintended behavior.

Always include break or return at the end of each case (unless you intentionally group cases).

Mistake 2 — Off-by-one errors in for loops

for (int i = 0; i <= array.Length; i++) — accesses index out of bounds.

Use i < array.Length to iterate from 0 to Length-1.

Mistake 3 — Infinite loops

while (true) { } without a break or a condition that eventually becomes false.

Ensure the loop condition changes inside the loop, or use break at the right time.

Mistake 4 — Using == to compare strings in if

Actually == works for strings in C#, but it's culture-sensitive in some contexts. For exact ordinal comparison, use string.Equals(a, b, StringComparison.Ordinal).

Mistake 5 — Overcomplicating with nested if

Deeply nested if blocks can be hard to read and maintain.

Consider refactoring to switch expressions, early returns, or guard clauses.

When Should I Use It?

Use if-else when:

• You have a simple true/false decision.
• You need to check multiple conditions that aren't based on a single value.
• You want to short-circuit with && or ||.

Use switch when:

• You're comparing the same variable against multiple constant values.
• You can benefit from pattern matching (type, property, relational patterns).
• You want a concise expression that returns a value.

Use for when:

• You know the exact number of iterations.
• You need index access or need to modify the loop variable.

Use foreach when:

• You need to iterate over all elements of a collection.
• You don't need to change the collection or the loop variable.

Use while / do-while when:

• The number of iterations is unknown and depends on a condition.
• do-while when you need at least one execution.

Mental Model

Key Takeaway

Check Your Understanding

You've seen how control flow statements work, how to choose between them, and common pitfalls. Let's test your ability to reason about them.

int x = 5;
if (x > 10)
    Console.WriteLine("A");
else if (x > 3)
    Console.WriteLine("B");
else
    Console.WriteLine("C");

int score = 75;
string grade = score switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    _ => "F"
};
Console.WriteLine(grade);

You've mastered control flow — now you can make your programs make decisions and repeat actions!

dotnetmadeeasy.com — Learn C# and .NET, the right way.