如果我有一个嵌套在另一个循环中的 for 循环，我怎样才能以最快的方式有效地退出两个循环（内部和外部）？
我不想必须使用布尔值然后不得不说转到另一个方法，而只是在外循环之后执行第一行代码。
有什么快速又好的方法来解决这个问题？
我认为异常并不便宜/应该只在真正异常的情况下抛出等。因此，从性能角度来看，我认为这种解决方案不会很好。
我认为利用 .NET 中的新功能（匿名方法）来做一些非常基础的事情是不对的。
【问题讨论】：
标签： c# for-loop nested-loops
我认为，除非您想做“布尔值”，否则唯一的解决方案实际上就是抛出。你显然不应该这样做..！
【讨论】：
好吧，goto，但这很丑陋，而且并不总是可能的。您还可以将循环放入方法（或匿名方法）中，然后使用return 退出回到主代码。
// goto
for (int i = 0; i < 100; i++)
{
for (int j = 0; j < 100; j++)
{
goto Foo; // yeuck!
}
}
Foo:
Console.WriteLine("Hi");
对比：
// anon-method
Action work = delegate
{
for (int x = 0; x < 100; x++)
{
for (int y = 0; y < 100; y++)
{
return; // exits anon-method
}
}
};
work(); // execute anon-method
Console.WriteLine("Hi");
请注意，在 C# 7 中，我们应该获得“本地函数”，这（语法待定等）意味着它应该像这样工作：
// local function (declared **inside** another method)
void Work()
{
for (int x = 0; x < 100; x++)
{
for (int y = 0; y < 100; y++)
{
return; // exits local function
}
}
};
Work(); // execute local function
Console.WriteLine("Hi");
【讨论】：
goto 是有害的per-se，而它只是正确 b> 仪器做一些事情，和很多仪器一样可能被误用。坦率地说，这种对goto 的宗教厌恶非常愚蠢，而且绝对不科学。
goto 似乎很奇怪，但它不像其他语言那样有标签 break 或 continue。鉴于这种语言限制，我认为goto 正是解决此问题的正确方法。
是否可以将嵌套的 for 循环重构为私有方法？这样你就可以简单地从方法中“返回”退出循环。
【讨论】：
[&] { ... return; ... }();
请不要引用我的话，但您可以按照 MSDN 中的建议使用 goto。还有其他解决方案，包括在两个循环的每次迭代中检查的标志。最后，您可以使用异常作为解决问题的真正重量级解决方案。
转到：
for ( int i = 0; i < 10; ++i ) {
for ( int j = 0; j < 10; ++j ) {
// code
if ( break_condition ) goto End;
// more code
}
}
End: ;
条件：
bool exit = false;
for ( int i = 0; i < 10 && !exit; ++i ) {
for ( int j = 0; j < 10 && !exit; ++j ) {
// code
if ( break_condition ) {
exit = true;
break; // or continue
}
// more code
}
}
例外：
try {
for ( int i = 0; i < 10 && !exit; ++i ) {
for ( int j = 0; j < 10 && !exit; ++j ) {
// code
if ( break_condition ) {
throw new Exception()
}
// more code
}
}
catch ( Exception e ) {}
【讨论】：
在外循环中使用合适的防护。在你中断之前在内部循环中设置守卫。
bool exitedInner = false;
for (int i = 0; i < N && !exitedInner; ++i) {
.... some outer loop stuff
for (int j = 0; j < M; ++j) {
if (sometest) {
exitedInner = true;
break;
}
}
if (!exitedInner) {
... more outer loop stuff
}
}
或者更好的是，将内循环抽象为一个方法，当它返回 false 时退出外循环。
for (int i = 0; i < N; ++i) {
.... some outer loop stuff
if (!doInner(i, N, M)) {
break;
}
... more outer loop stuff
}
【讨论】：
考虑到一个函数/方法并使用提前返回，或者将你的循环重新排列成一个while子句。 goto/exceptions/whatever 在这里肯定不合适。
def do_until_equal():
foreach a:
foreach b:
if a==b: return
【讨论】：
您要求将快速、美观、不使用布尔值、不使用 goto 和 C# 结合起来。你已经排除了所有可能的方式来做你想做的事。
最快最不难看的方法是使用 goto。
【讨论】：
C# 适应 C 中常用的方法 - 在循环条件之外设置外循环变量的值（即，使用 int 变量 INT_MAX -1 的 for 循环通常是不错的选择）：
for (int i = 0; i < 100; i++)
{
for (int j = 0; j < 100; j++)
{
if (exit_condition)
{
// cause the outer loop to break:
// use i = INT_MAX - 1; otherwise i++ == INT_MIN < 100 and loop will continue
i = int.MaxValue - 1;
Console.WriteLine("Hi");
// break the inner loop
break;
}
}
// if you have code in outer loop it will execute after break from inner loop
}
正如代码中的注释所说，break 不会神奇地跳转到外循环的下一次迭代 - 因此，如果您有在内循环之外的代码，这种方法需要更多检查。在这种情况下考虑其他解决方案。
这种方法适用于for 和while 循环，但不适用于foreach。在foreach 的情况下，您将无法访问隐藏的枚举器的代码，因此您无法更改它（即使您可以，IEnumerator 也没有一些“MoveToEnd”方法）。
致谢内联 cmets 的作者：
i = INT_MAX - 1Meta 的建议
for/foreachygoe 发表评论。
正确的IntMax by jmbpiano
blizpasta关于内循环后代码的备注
【讨论】：
自从几十年前我第一次在 C 中看到 break 以来，这个问题一直困扰着我。我希望某些语言增强功能可以扩展 break 从而起作用：
break; // our trusty friend, breaks out of current looping construct.
break 2; // breaks out of the current and it's parent looping construct.
break 3; // breaks out of 3 looping constructs.
break all; // totally decimates any looping constructs in force.
【讨论】：
我见过很多使用“break”但没有使用“continue”的示例。
它仍然需要内部循环中的某种标志：
while( some_condition )
{
// outer loop stuff
...
bool get_out = false;
for(...)
{
// inner loop stuff
...
get_out = true;
break;
}
if( get_out )
{
some_condition=false;
continue;
}
// more out loop stuff
...
}
【讨论】：
此解决方案不适用于 C#
对于通过其他语言发现此问题的人，Javascript、Java 和 D 允许标记中断并继续：
outer: while(fn1())
{
while(fn2())
{
if(fn3()) continue outer;
if(fn4()) break outer;
}
}
【讨论】：
bool breakInnerLoop=false
for(int i=0;i<=10;i++)
{
for(int J=0;i<=10;i++)
{
if(i<=j)
{
breakInnerLoop=true;
break;
}
}
if(breakInnerLoop)
{
continue
}
}
【讨论】：
我记得在我的学生时代，有人说从数学上证明你可以在没有 goto 的情况下在代码中做任何事情（即没有任何情况下 goto 是唯一的答案）。所以，我从不使用 goto（只是我个人的喜好，不代表我是对还是错）
无论如何，为了打破嵌套循环，我会这样做：
var isDone = false;
for (var x in collectionX) {
for (var y in collectionY) {
for (var z in collectionZ) {
if (conditionMet) {
// some code
isDone = true;
}
if (isDone)
break;
}
if (isDone)
break;
}
if (isDone)
break;
}
...我希望对那些喜欢我的人有所帮助是反goto“fanboys”:)
【讨论】：
有时将代码抽象为它自己的函数而不是使用提前返回——虽然提前返回是邪恶的：）
public void GetIndexOf(Transform transform, out int outX, out int outY)
{
outX = -1;
outY = -1;
for (int x = 0; x < Columns.Length; x++)
{
var column = Columns[x];
for (int y = 0; y < column.Transforms.Length; y++)
{
if(column.Transforms[y] == transform)
{
outX = x;
outY = y;
return;
}
}
}
}
【讨论】：
您甚至看过break 关键字吗？哎哟
这只是伪代码，但你应该能明白我的意思：
<?php
for(...) {
while(...) {
foreach(...) {
break 3;
}
}
}
如果你认为break 是一个类似break() 的函数，那么它的参数就是要跳出的循环数。由于我们在此处的代码中处于第三个循环，因此我们可以打破所有三个循环。
【讨论】：
抛出一个自定义异常，该异常退出外部循环。
它适用于 for、foreach 或 while 或任何类型的循环和任何使用 try catch exception 块的语言
try
{
foreach (object o in list)
{
foreach (object another in otherList)
{
// ... some stuff here
if (condition)
{
throw new CustomExcpetion();
}
}
}
}
catch (CustomException)
{
// log
}
【讨论】：
我看到你接受了这个人提到你的 goto 语句的答案，在现代编程和专家意见中 goto 是一个杀手，我们称它为编程中的杀手，有一些特定的原因，我不会讨论此时就到这里了，但是您的问题的解决方案非常简单，您可以在这种情况下使用布尔标志，就像我将在我的示例中演示的那样：
for (; j < 10; j++)
{
//solution
bool breakme = false;
for (int k = 1; k < 10; k++)
{
//place the condition where you want to stop it
if ()
{
breakme = true;
break;
}
}
if(breakme)
break;
}
简单明了。 :)
【讨论】：
在我看来，人们似乎非常不喜欢 goto 声明，所以我觉得有必要稍微澄清一下。
我相信人们对goto 的“情绪”最终归结为对代码的理解以及对可能的性能影响的（误解）。因此，在回答这个问题之前，我将首先详细介绍它是如何编译的。
众所周知，C# 编译为 IL，然后使用 SSA 编译器编译为汇编器。我将对这一切如何运作提供一些见解，然后尝试回答问题本身。
从 C# 到 IL
首先我们需要一段 C# 代码。让我们从简单的开始：
foreach (var item in array)
{
// ...
break;
// ...
}
我将逐步执行此操作，让您对幕后发生的事情有一个很好的了解。
第一次翻译：从foreach 到等效的for 循环（注意：我在这里使用数组，因为我不想深入了解 IDisposable 的细节——在这种情况下，我也会有使用 IEnumerable）：
for (int i=0; i<array.Length; ++i)
{
var item = array[i];
// ...
break;
// ...
}
第二次翻译：for 和 break 被翻译成更简单的等价物：
int i=0;
while (i < array.Length)
{
var item = array[i];
// ...
break;
// ...
++i;
}
第三次翻译（这相当于IL代码）：我们把break和while改成一个分支：
int i=0; // for initialization
startLoop:
if (i >= array.Length) // for condition
{
goto exitLoop;
}
var item = array[i];
// ...
goto exitLoop; // break
// ...
++i; // for post-expression
goto startLoop;
虽然编译器在一个步骤中完成了这些事情，但它可以让您深入了解该过程。从 C# 程序演变而来的 IL 代码是最后一个 C# 代码的直译。您可以在这里亲自查看：https://dotnetfiddle.net/QaiLRz（点击“查看 IL”）
现在，您在这里观察到的一件事是，在此过程中，代码变得更加复杂。观察这一点的最简单方法是我们需要越来越多的代码来完成同样的事情。你可能还会争辩说foreach、for、while 和break 实际上是goto 的简写，这在一定程度上是正确的。
从 IL 到汇编程序
.NET JIT 编译器是一个 SSA 编译器。我不会在这里详细介绍 SSA 表单的所有细节以及如何创建优化编译器，它太多了，但可以对将会发生的事情给出一个基本的了解。为了更深入地了解，最好开始阅读优化编译器（我喜欢这本书的简要介绍：http://ssabook.gforge.inria.fr/latest/book.pdf）和 LLVM (llvm.org)。
每个优化编译器都依赖于代码简单并遵循可预测模式这一事实。在 FOR 循环的情况下，我们使用图论来分析分支，然后在我们的分支中优化诸如循环之类的东西（例如向后分支）。
但是，我们现在有了前向分支来实现我们的循环。您可能已经猜到了，这实际上是 JIT 修复的第一步，如下所示：
int i=0; // for initialization
if (i >= array.Length) // for condition
{
goto endOfLoop;
}
startLoop:
var item = array[i];
// ...
goto endOfLoop; // break
// ...
++i; // for post-expression
if (i >= array.Length) // for condition
{
goto startLoop;
}
endOfLoop:
// ...
如您所见，我们现在有一个向后分支，这是我们的小循环。这里唯一仍然令人讨厌的是由于我们的break 语句而最终得到的分支。在某些情况下，我们可以以相同的方式移动它，但在其他情况下，它会一直存在。
那么为什么编译器会这样做呢？好吧，如果我们可以展开循环，我们也许可以对其进行矢量化。我们甚至可以证明只是添加了常量，这意味着我们的整个循环可能会化为乌有。总结一下：通过使模式可预测（通过使分支可预测），我们可以证明某些条件在我们的循环中成立，这意味着我们可以在 JIT 优化期间发挥作用。
但是，分支往往会破坏那些很好的可预测模式，因此优化人员不太喜欢这种情况。 Break、continue、goto——它们都打算打破这些可预测的模式——因此并不是真正的“好”。
此时您还应该意识到，一个简单的foreach 比一堆到处乱跑的goto 语句更容易预测。就（1）可读性和（2）从优化器的角度来看，它都是更好的解决方案。
另一件值得一提的是，它与优化编译器以将寄存器分配给变量非常相关（一个称为寄存器分配的过程）。您可能知道，您的 CPU 中只有有限数量的寄存器，它们是迄今为止硬件中最快的内存。在最内层循环中的代码中使用的变量更有可能被分配一个寄存器，而循环之外的变量则不太重要（因为此代码可能被命中较少）。
求助，太复杂了……我该怎么办？
最重要的是，您应该始终使用您可以使用的语言结构，这通常会（隐含地）为您的编译器构建可预测的模式。如果可能，尽量避免使用奇怪的分支（特别是：break、continue、goto 或 return 中间什么都没有）。
这里的好消息是，这些可预测的模式既易于阅读（对人类而言），又易于发现（对编译器而言）。
其中一种模式称为 SESE，代表 Single Entry Single Exit。
现在我们来解决真正的问题。
想象一下你有这样的东西：
// a is a variable.
for (int i=0; i<100; ++i)
{
for (int j=0; j<100; ++j)
{
// ...
if (i*j > a)
{
// break everything
}
}
}
使其成为可预测模式的最简单方法是完全消除if：
int i, j;
for (i=0; i<100 && i*j <= a; ++i)
{
for (j=0; j<100 && i*j <= a; ++j)
{
// ...
}
}
在其他情况下，您也可以将方法拆分为 2 个方法：
// Outer loop in method 1:
for (i=0; i<100 && processInner(i); ++i)
{
}
private bool processInner(int i)
{
int j;
for (j=0; j<100 && i*j <= a; ++j)
{
// ...
}
return i*j<=a;
}
临时变量？好、坏还是丑？
您甚至可以决定从循环中返回一个布尔值（但我个人更喜欢 SESE 形式，因为这是编译器会看到它的方式，而且我认为它更易于阅读）。
有些人认为使用临时变量更干净，并提出这样的解决方案：
bool more = true;
for (int i=0; i<100; ++i)
{
for (int j=0; j<100; ++j)
{
// ...
if (i*j > a) { more = false; break; } // yuck.
// ...
}
if (!more) { break; } // yuck.
// ...
}
// ...
我个人反对这种做法。再看一下代码是如何编译的。现在想想这将如何处理这些漂亮的、可预测的模式。得到图片？
好吧，让我把它拼出来。会发生什么：
more 变量。 more将从程序中删除，只保留分支。这些分支将被优化，因此您只会从内部循环中获得一个分支。more肯定会用在最内层循环中，所以如果编译器不优化它，它很有可能被分配给一个寄存器（这会占用宝贵的寄存器内存)。所以，总而言之：编译器中的优化器会遇到很多麻烦，以找出 more 仅用于控制流，并且在最佳情况下 会将其转换为外部 for 循环之外的单个分支。
换句话说，最好的情况是它最终会得到这样的结果：
for (int i=0; i<100; ++i)
{
for (int j=0; j<100; ++j)
{
// ...
if (i*j > a) { goto exitLoop; } // perhaps add a comment
// ...
}
// ...
}
exitLoop:
// ...
我个人对此的看法很简单：如果这是我们一直以来的意图，那么让我们让编译器和可读性的世界变得更容易，并立即编写。
tl;博士：
底线：
goto 或bool more，请选择前者。【讨论】：
yield return。也就是说，虽然很容易展示一些有用的案例，但对于大多数“应用程序级”代码来说，C# 的挫败感可能非常低，不包括那些“刚刚来自”C/C++ 的案例；-) 我偶尔也会错过Ruby 的“抛出”（非异常展开）有时也适合这个领域。
goto，并不会使您的代码更具可读性 - 我认为发生的情况恰恰相反：实际上您控制流将包含更多节点——这几乎是复杂性的定义。仅仅避免它以帮助自律听起来在可读性方面适得其反。
goto 的人只是没有纪律不滥用它。
我就是这样做的。仍然是一种解决方法。
foreach (var substring in substrings) {
//To be used to break from 1st loop.
int breaker=1;
foreach (char c in substring) {
if (char.IsLetter(c)) {
Console.WriteLine(line.IndexOf(c));
\\setting condition to break from 1st loop.
breaker=9;
break;
}
}
if (breaker==9) {
break;
}
}【讨论】：
结束双循环最简单的方法是直接结束第一个循环
string TestStr = "The frog jumped over the hill";
char[] KillChar = {'w', 'l'};
for(int i = 0; i < TestStr.Length; i++)
{
for(int E = 0; E < KillChar.Length; E++)
{
if(KillChar[E] == TestStr[i])
{
i = TestStr.Length; //Ends First Loop
break; //Ends Second Loop
}
}
}
【讨论】：
可以使用循环中的自定义条件来打破循环，从而获得干净的代码。
static void Main(string[] args)
{
bool isBreak = false;
for (int i = 0; ConditionLoop(isBreak, i, 500); i++)
{
Console.WriteLine($"External loop iteration {i}");
for (int j = 0; ConditionLoop(isBreak, j, 500); j++)
{
Console.WriteLine($"Inner loop iteration {j}");
// This code is only to produce the break.
if (j > 3)
{
isBreak = true;
}
}
Console.WriteLine("The code after the inner loop will be executed when breaks");
}
Console.ReadKey();
}
private static bool ConditionLoop(bool isBreak, int i, int maxIterations) => i < maxIterations && !isBreak;
使用此代码，我们获得以下输出：
【讨论】：
最干净、最短和最可重用的方式是自调用匿名函数：
使用匿名方法比最佳答案短一行。
new Action(() =>
{
for (int x = 0; x < 100; x++)
{
for (int y = 0; y < 100; y++)
{
return; // exits self invoked lambda expression
}
}
})();
Console.WriteLine("Hi");
【讨论】：
此处未提及的另一个既干净又不依赖于较新的 .NET 功能的选项是将双循环合并为产品上的单循环。然后在循环内部，可以使用简单的数学计算计数器的值：
int n; //set to max of first loop
int m; //set to max of second loop
for (int k = 0; k < n * m; k++)
{
//calculate the values of i and j as if there was a double loop
int i = k / m;
int j = k % m;
if(exitCondition)
{
break;
}
}
【讨论】：