break将完全停止foreach循环，continue将跳到下一个DataRow。

break将完全退出循环，continue将跳过当前迭代。

例如：

for (int i = 0; i < 10; i++) {
    if (i == 0) {
        break;
    }

    DoSomeThingWith(i);
}

中断将导致循环在第一次迭代时退出-DoSomeThingWith将永远不会执行。此处为：

for (int i = 0; i < 10; i++) {
    if(i == 0) {
        continue;
    }

    DoSomeThingWith(i);
}

对于i=0，将不执行DoSomeThingWith，但循环将继续，并且对于i=1到i=9，将执行DoSome ThingWith。

要理解这一点，一个非常简单的方法是在每个关键字后面加上单词“loop”。如果这些术语只是像日常用语一样阅读，那么它们现在就有意义了。

中断循环-循环中断并停止。

continue循环-循环继续执行下一次迭代。

有很多人不喜欢休息和继续。我最近看到的关于他们的投诉是在道格拉斯·克罗克福德的《JavaScript：好零件》中。但我发现，有时使用其中一个确实会简化事情，特别是当您的语言不包含do-while或do-wil循环样式时。

我倾向于使用插入循环来搜索列表中的内容。一旦被发现，就没有继续下去的意义，所以你最好退出。

我使用continue来处理列表中的大多数元素，但仍然想跳过一些元素。

当轮询某人或某物的有效响应时，break语句也很有用。而不是：

Ask a question
While the answer is invalid:
    Ask the question

您可以消除一些重复并使用：

While True:
    Ask a question
    If the answer is valid:
        break

我之前提到的do until循环是该特定问题的更优雅的解决方案：

Do:
    Ask a question
    Until the answer is valid

不需要重复，也不需要中断。

不幸的是，Ruby有点不同。PS：我的记忆有点模糊，所以如果我错了，请道歉

它有break/next，而不是break/content，它们在循环方面的行为相同

循环（和其他一切一样）是表达式，并“返回”它们所做的最后一件事。大多数时候，从循环中获取返回值是没有意义的，所以每个人都这样做

a = 5
while a < 10
    a + 1
end

但是，您可以这样做

a = 5
b = while a < 10
    a + 1
end # b is now 10

然而，许多ruby代码通过使用块来“模拟”循环。典型的例子是

10.times do |x|
    puts x
end

由于人们更常见的是想用街区的结果来做事，所以这就是变得混乱的地方。break/next在块的上下文中表示不同的东西。

break将跳出调用块的代码

接下来将跳过块中的其余代码，并将您指定的内容“返回”给块的调用者。没有例子，这毫无意义。

def timesten
    10.times{ |t| puts yield t }
end


timesten do |x|
   x * 2
end
# will print
2
4
6
8 ... and so on


timesten do |x|
    break
    x * 2
end
# won't print anything. The break jumps out of the timesten function entirely, and the call to `puts` inside it gets skipped

timesten do |x|
    break 5
    x * 2
end
# This is the same as above. it's "returning" 5, but nobody is catching it. If you did a = timesten... then a would get assigned to 5

timesten do |x|
    next 5
    x * 2
end 
# this would print
5
5
5 ... and so on, because 'next 5' skips the 'x * 2' and 'returns' 5.

所以是的。Ruby很棒，但它有一些可怕的角落。这是我多年来用过的第二糟糕的：-）

break导致程序计数器跳出最内层循环的范围

for(i = 0; i < 10; i++)
{
    if(i == 2)
        break;
}

像这样工作

for(i = 0; i < 10; i++)
{
    if(i == 2)
        goto BREAK;
}
BREAK:;

continue跳转到循环的末尾。在for循环中，continue跳转到增量表达式。

for(i = 0; i < 10; i++)
{
    if(i == 2)
        continue;

    printf("%d", i);
}

像这样工作

for(i = 0; i < 10; i++)
{
    if(i == 2)
        goto CONTINUE;

    printf("%d", i);

    CONTINUE:;
}

简单答案：

Break立即退出循环。继续开始处理下一项。（如果有，跳转到for/while的评估行）

请让我说明一点：请注意，既不添加中断，也不添加继续，将恢复您的程序；也就是说，我被某个错误捕获，然后在记录它之后，我想继续处理，下一行之间还有更多的代码任务，所以我就让它失败了。

所有人都给出了很好的解释。我仍然在发布我的答案，只是想举个例子，如果这有帮助的话。

// break statement
for (int i = 0; i < 5; i++) {
    if (i == 3) {
        break; // It will force to come out from the loop
    }

    lblDisplay.Text = lblDisplay.Text + i + "[Printed] ";
}

以下是输出：

0[打印]1[打印]2[打印]

因此，当i==3时，3[打印]和4[打印]将不会显示，因为有中断

//continue statement
for (int i = 0; i < 5; i++) {
    if (i == 3) {
        continue; // It will take the control to start point of loop
    }

    lblDisplay.Text = lblDisplay.Text + i + "[Printed] ";
}

以下是输出：

0[打印]1[打印]2[打印]4[打印]

因此，当i==3时，不会显示3[已打印]，因为会继续

要完全脱离foreach循环，使用break；

要转到循环中的下一个迭代，请使用continue；

如果您在对象集合（如数据表中的行）中循环，并且正在搜索特定的匹配项，则中断非常有用，当您找到匹配项时，无需继续遍历剩余的行，因此您需要中断。

当您完成了循环迭代中所需的任务时，Continue非常有用。通常情况下，你会在一个if之后继续。

打破

中断将强制循环立即退出。

持续

这与break相反。它没有终止循环，而是立即再次循环，跳过其余的代码。

举个例子

foreach(var i in Enumerable.Range(1,3))
{
    Console.WriteLine(i);
}

打印1、2、3（在单独的行上）。

在i=2时添加中断条件

foreach(var i in Enumerable.Range(1,3))
{
    if (i == 2)
        break;

    Console.WriteLine(i);
}

现在循环打印1并停止。

用continue替换中断。

foreach(var i in Enumerable.Range(1,3))
{
    if (i == 2)
        continue;

    Console.WriteLine(i);
}

现在循环打印1和3（跳过2）。

因此，break会停止循环，而continue会跳到下一次迭代。

若你们不想使用break，你们只需要增加I的值，这样就可以使迭代条件为假，并且循环不会在下一次迭代时执行。

for(int i = 0; i < list.Count; i++){
   if(i == 5)
    i = list.Count;  //it will make "i<list.Count" false and loop will exit
}

何时使用中断与继续？

分手-我们将永远离开循环，永远分手。再见。

继续-意味着你今天要休息一下，明天再把它整理好（即跳过当前迭代）！

（Corny故事）\(ツ)/“”和图片，但希望能帮助你记住。

抓握提醒：不知道为什么要使用这些词。如果您想跳过迭代，为什么不使用skip而不是continue？如果给出了正确的名称，整个堆栈溢出问题和1000名开发人员不会感到困惑。）

至于其他语言：

    'VB
    For i=0 To 10
       If i=5 then Exit For '= break in C#;
       'Do Something for i<5
    next
     
    For i=0 To 10
       If i=5 then Continue For '= continue in C#
       'Do Something for i<>5...
    Next

由于这里编写的示例对于理解这个概念非常简单，所以我认为查看所使用的continue语句的更实用版本也是一个好主意。例如：

我们要求用户输入5个唯一的数字，如果数字已经输入，我们会给他们一个错误，然后继续我们的程序。

static void Main(string[] args)
        {
            var numbers = new List<int>();


            while (numbers.Count < 5)
            { 
            
                Console.WriteLine("Enter 5 uniqe numbers:");
                var number = Convert.ToInt32(Console.ReadLine());



                if (numbers.Contains(number))
                {
                    Console.WriteLine("You have already entered" + number);
                    continue;
                }



                numbers.Add(number);
            }


            numbers.Sort();


            foreach(var number in numbers)
            {
                Console.WriteLine(number);
            }


        }

假设用户输入为1,2,2,2,3,4,5，则打印的结果为：

1,2,3,4,5

为什么？因为每次用户输入一个已经在列表中的数字时，我们的程序都会忽略它，并且不会将列表中的内容添加到列表中。现在，如果我们尝试相同的代码，但没有continue语句，让我们假设来自用户的相同输入是1,2,2,2,3,4,5。输出将是：

1,2,2,2,3,4

为什么？因为没有continue语句让我们的程序知道它应该忽略已经输入的数字。

现在，对于Break语句，我再次认为最好用例子来说明。例如：

在这里，我们希望我们的程序不断地要求用户输入一个数字。当用户键入“ok”时，我们希望循环终止，最后计算之前输入的所有数字的总和并将其显示在控制台上。

以下是break语句在本示例中的用法：

{
            var sum = 0;
            while (true)
            {
                Console.Write("Enter a number (or 'ok' to exit): ");
                var input = Console.ReadLine();

                if (input.ToLower() == "ok")
                    break;

                sum += Convert.ToInt32(input);
            }
            Console.WriteLine("Sum of all numbers is: " + sum);
        }

程序将要求用户输入一个数字，直到用户键入“OK”，然后才会显示结果。为什么？因为break语句在达到所需条件时完成或停止正在进行的过程。

如果没有break语句，程序将继续运行，当用户键入“ok”时不会发生任何事情。

我建议复制此代码并尝试删除或添加这些语句，然后自己查看更改。