C# break vs continue in Loops: Differences and Examples

break stops the entire nearest loop immediately. continue skips the rest of the current iteration and starts the next iteration, if one exists. This page explains when to use each statement safely in C#.

A loop repeats a block of code for multiple values, such as every row in a table. Sometimes a program needs to change that normal flow:

• Use break when the loop has finished its job and should stop completely.
• Use continue when the current item should be ignored but later items may still matter.

In a foreach loop, break exits the foreach statement. Execution resumes at the first statement after the loop.

continue does not leave the loop. It skips any remaining statements in the current loop body and moves to the next item in the collection.

These statements matter because they make searches, filtering, validation, and data-processing code clearer. They can also avoid unnecessary work—for example, stopping as soon as a required record is found.

Imagine checking books on a shelf:

• break means: “I found the book I need. Stop checking shelves and leave the library aisle.”
• continue means: “This book is not relevant. Skip it and check the next book.”

break ends the task. continue rejects one item while keeping the task going.

The basic syntax is:

foreach (DataRow row in myTable.Rows)
{
    if (condition)
    {
        break;    // Exit the loop entirely
        // continue; // Skip this item and process the next one
    }
}

break: stop after finding a match

int[] scores = { 55, 72, 90, 61 };

foreach (int score in scores)
{
    if (score >= 90)
    {
        Console.WriteLine("Excellent score found.");
        break;
    }

    Console.WriteLine($"Checked: {score}");
}

Console.WriteLine("Finished checking scores.");

Output:

Checked: 55
Checked: 72
Excellent score found.
Finished checking scores.

When 90 is found, break exits the loop. The value 61 is never checked.

: skip unwanted values

Consider this code:

int[] numbers = { 1, 2, 3, 4, 5 };

foreach (int number in numbers)
{
    if (number == 3)
    {
        continue;
    }

    if (number == 5)
    {
        break;
    }

    Console.WriteLine(number);
}

Console.WriteLine("Loop ended.");

Execution trace:

1. number is 1.
   • It is not 3 or 5.
   • 1 is printed.
2. number is 2.
   • It is not 3 or 5.
   • 2 is printed.
3. number is .

Stop searching after a match

Use break when only the first matching item is needed.

DataRow? matchingRow = null;

foreach (DataRow row in myTable.Rows)
{
    if (row.Field<int>("Id") == requestedId)
    {
        matchingRow = row;
        break;
    }
}

Ignore incomplete data rows

Use continue when invalid rows should not prevent later rows from being processed.

foreach (DataRow row in myTable.Rows)
{
    if (row.IsNull("Email"))
    {
        continue;
    }

    SendEmail(row.Field<string>("Email")!);
}

Stop reading a file at an end marker

foreach (string line in File.ReadLines("report.txt"))
{
    if (line == "END")
    {
        break;
    }

    ProcessLine(line);
}

Skip comments or blank lines in imported text

In production code, break and continue are usually used to make loop intent explicit.

Search loops often use break

A loop that searches for one item can stop as soon as it succeeds:

User? foundUser = null;

foreach (User user in users)
{
    if (user.Id == userId)
    {
        foundUser = user;
        break;
    }
}

In many C# codebases, this can also be expressed with LINQ when it improves readability:

User? foundUser = users.FirstOrDefault(user => user.Id == userId);

Data-processing loops often use continue

A common pattern is a guard clause near the top of the loop. It removes invalid or irrelevant items early, keeping the main work less nested.

foreach (Order order in orders)
{
    if (order.IsCancelled)
    {
        continue;
    }

    if (order.Total <= 0)
    {
        continue;
    }

    invoiceService.CreateInvoice(order);
}

Important design guideline

Use these statements when they make control flow easier to read. If a loop has many and paths, consider extracting part of the work into a method with a clear name, such as or .

Expecting continue to exit the loop

This code still processes later numbers:

foreach (int number in numbers)
{
    if (number == 3)
    {
        continue;
    }

    Console.WriteLine(number);
}

Use break instead if finding 3 should end the loop.

Expecting break to skip only one item

foreach (int number in numbers)
{
    if (number < 0)
    {
        break; // Stops processing all remaining numbers.
    }

    Process(number);
}

If negative values should be ignored rather than end processing, use continue.

foreach (int number in numbers)
{
    if (number < 0)
    {
        continue;
    }

    Process(number);
}

Writing code after or in the same block

break versus return

foreach (int number  numbers)
{
     (number == )
    {
        ;
    }
}

Console.WriteLine();

break;    // Leave the nearest loop immediately.
continue; // Skip the current iteration; begin the next iteration.
return;   // Leave the entire current method.

Key rules:

• break and continue work in loops such as for, foreach, while, and do.
• break exits only the nearest nested loop.

Does break exit a foreach loop in C#?

Yes. break immediately exits the nearest foreach loop. Execution continues after that loop.

Does continue exit a C# loop?

No. continue exits only the current iteration. The loop then moves to its next iteration if there is one.

What happens when continue is used in a foreach loop?

C# stops executing the rest of the loop body for the current item and retrieves the next item from the collection.

Can I use break inside nested loops?

Yes, but it exits only the innermost loop containing that break. It does not automatically exit outer loops.

Should I use break when I find the first matching item?

Usually, yes, if you do not need to inspect later items. This avoids unnecessary processing.

Is continue bad practice?

No. It is useful for skipping invalid or irrelevant data. Avoid it only when it makes already-complex control flow harder to follow.

Can code run after or in the same block?

• C# foreach loops — break and continue are frequently used while iterating through collections.
• for and while loops — the same control-flow statements work in these loop types, with some differences in iteration updates.
• return statements — return leaves a method, while break leaves only the nearest loop.
• Nested loops — understanding nesting explains why break exits only one loop level.
• Guard clauses — continue is commonly used as a loop-level guard clause for invalid data.
• LINQ FirstOrDefault and Where — LINQ can express common search and filtering loops declaratively.
• Exception handling — exceptions alter control flow too, but they are intended for exceptional error conditions rather than ordinary loop decisions.