Salir de un bucle foreach desde dentro de un bloque de conmutadores

Question

¿Cómo se puede salir de un bucle foreach mientras se está dentro de un bloque de conmutadores?

Normalmente, se utiliza descanso, pero si se utiliza un descanso dentro de un bloque de interruptores que sólo te va a salir de un bloque de interruptores y el bucle foreach continuará la ejecución:

foreach (var v in myCollection) 
{ 
    switch (v.id) 
    { 
     case 1: 
      if (true) 
      { 
       break; 
      } 
      break; 
     case 2; 
      break 
    } 
} 

Lo que estoy haciendo actualmente cuando necesito salir del foreach mientras estoy dentro del bloque switch estableciendo un valor bool colocado fuera del lazo en verdadero y comprobando el valor de este bool cada vez que se ingresa el foreach y antes de ingresar al bloque de interruptores. Algo como esto:

bool exitLoop; 
foreach (var v in myCollection) 
{ 
    if (exitLoop) break; 
    switch (v.id) 
    { 
     case 1: 
      if (true) 
      { 
       exitLoop = true; 
       break; 
      } 
      break; 
     case 2; 
      break 
    } 
} 

Esto funciona, pero no dejo de pensar que debe haber una mejor manera de hacer esto soy consciente de ...

EDIT: Me pregunto por qué esto no se implementó en .NET la realidad forma ordenada funciona en PHP según lo mencionado por @jon_darkstar?

$i = 0; 
while (++$i) { 
    switch ($i) { 
    case 5: 
     echo "At 5<br />\n"; 
     break 1; /* Exit only the switch. */ 
    case 10: 
     echo "At 10; quitting<br />\n"; 
     break 2; /* Exit the switch and the while. */ 
    default: 
     break; 
    } 
} 

Answer 1

Su solución es prácticamente la opción más común en este caso. Dicho esto, me gustaría poner su cheque de salida al final:

bool exitLoop; 
foreach (var v in myCollection) 
{ 
    switch (v.id) 
    { 
     case 1: 
      if (true) 
      { 
       exitLoop = true; 
      } 
      break; 
     case 2; 
      break 
    } 

    // This saves an iteration of the foreach... 
    if (exitLoop) break; 
} 

La otra opción principal es refactorizar su código, y tire de la sentencia switch y el bucle foreach a cabo en un método separado. Entonces podría simplemente return desde el interior de la declaración del interruptor.

Answer 2

¿Honestamente? Esta es quizás la única situación en la que es totalmente válida y correcta de usar goto:

foreach (var v in myCollection) { 
    switch (v.id) { 
     case 1: 
      if (true) 
       // document why we're using goto 
       goto finished; 
      break; 
     case 2; 
      break 
    } 
} 
finished: // document why I'm here 

Answer 3

Usted puede extraer su ciclo foreach para el método separado y utilizar return comunicado. O podría hacer esto:

 foreach (object collectionElement in myCollection) 
     { 
      if (ProcessElementAndDetermineIfStop(collectionElement)) 
      { 
       break; 
      } 
     } 

     private bool ProcessElementAndDetermineIfStop(object collectionElement) 
     { 
      switch (v.id) 
      { 
       case 1: 
        return true; // break cycle. 
       case 2; 
        return false; // do not break cycle. 
      } 
     } 

Answer 4

Lame, lo sé, pero eso es todo lo que puede hacer al respecto.

Siempre puede transformarlo en un ciclo while y agregar 'exitLoop' como una condición que debe cumplirse. Dentro del interruptor, puede llamar para continuar salteando el resto del pase actual y como hubiera configurado exitLoop en falso, saldría de la misma manera que lo haría un salto. Aunque no es exactamente lo que estás preguntando, ¿quizás es más elegante de esa manera?

Answer 5

Siempre existe la opción de reestructurar su código para que pueda return de la declaración switch.

Answer 6

Basado en MSDN documentation en la declaración break, solo permite detener el alcance más alto.

Este caso es uno en el que podría usar una instrucción goto para dejar su bucle foreach. Si no desea utilizar una declaración goto, su solución parece ser la mejor.

Como nota al margen, podría mejorar su código probando el indicador exitLoop al final de la iteración, ahorrando el costo de una llamada al enumerador.

Answer 7

El booleano es de una sola dirección. Otra es usar etiquetas y goto. Sé que la gente considera que ser un pecado cardinal, pero usado juiciosamente (MUY juiciosamente), puede ser útil. En este caso, coloque una etiqueta justo después del final del ciclo foreach. Cuando desee salir del bucle, simplemente vaya a esa etiqueta. Por ejemplo:

foreach(var v in myCollection) { 
    switch(v.Id) { 
     case 1: 
      if(true) { 
       goto end_foreach; 
      } 
      break; 
     case 2: 
      break; 
    } 
} 
end_foreach: 
// ... code after the loop 

EDIT: algunas personas han mencionado tomando el bucle a cabo en un método separado para que pueda utilizar el rendimiento. Veo el beneficio de esto ya que no requiere goto y también simplifica la función original que contiene el bucle. Sin embargo, si el bucle es simple y es el propósito principal de la función que lo contiene, o si el bucle hace uso de las variables de salida o de referencia, entonces probablemente sea mejor dejarlo en su lugar y usar el goto. De hecho, debido a que el goto y la etiqueta se destacan, probablemente hace que el código sea más claro que en lugar de clunkier. Ponerlo en una función separada podría dificultar la lectura del código simple.

Answer 8

en realidad no es diferente de su bandera exitLoop, pero podría ser más legible si se extrae un método ...

foreach (var v in myCollection) 
{ 
    if(!DoStuffAndContinue(v)) 
     break; 
} 


bool DoStuffAndContinue(MyType v) 
{ 
    switch (v.id) 
    { 
     case 1: 
      if (ShouldBreakOutOfLoop(v)) 
      { 
       return false; 
      } 
      break; 
     case 2; 
      break; 
    } 
    return true; 
} 

Answer 9

Algunos idiomas (sé PHP es uno, no está seguro acerca de los demás) que permite para especificar de cuántas estructuras de control le gustaría salir con

break n;
donde 1 está implicado si solo rompe

break 2 haría lo que describe, si estuviera disponible en C#. No creo que ese sea el caso, por lo que su bandera de salida es probablemente la mejor solución.

Answer 10

Transforme la instrucción switch() en una serie "if() else if() [...] else" de instrucciones para que break salga del circuito foreach().

Answer 11

Puede hacerlo con Try/Catch .. Pero puede que no sea la mejor idea del mundo, ya que causa problemas de rendimiento y muestra líneas desagradables en la ventana de depuración.

try 
{ 
foreach (var v in myCollection) 
    { 
     switch (v.id) 
     { 
      case 1: 
       if (true) 
       { 
        throw new SystemException("Break"); 
       } 
       break; 
      case 2; 
       break; 
     } 
    } 
} catch {}