¿existe un equivalente de ruptura marcado de Java en C# o una solución

Question

Estoy convirtiendo algo de código Java a C# y he encontrado algunas declaraciones "romper" marcado (por ejemplo)

label1: 
    while (somethingA) { 
     ... 
     while (somethingB) { 
      if (condition) { 
       break label1; 
      } 
     } 
    } 

¿Hay un equivalente en C# (lectura actual sugiere que no) y si no hay ningún tipo de conversión que no sea (por ejemplo) que tienen banderas bool para indicar si se debe romper en cada extremo del bucle (por ejemplo)

bool label1 = false; 
while (somethingA) 
{ 
    ... 
    while (somethingB) 
    { 
     if (condition) 
     { 
      label1 = true; 
      break; 
     } 
    } 
    if (label1) 
    { 
     break; 
    } 
} 
// breaks to here 

estaría interesado en cuanto a porqué C# doesn No tengo esto, ya que no parece ser muy malo.

Answer 1

Puede simplemente usar goto para saltar directamente a una etiqueta.

while (somethingA) 
{ 
    // ... 
    while (somethingB) 
    { 
     if (condition) 
     { 
      goto label1; 
     } 
    } 
} 
label1: 
    // ... 

En los lenguajes C-como, goto menudo termina limpiador para romper bucles anidados, en contraposición a hacer el seguimiento de variables booleanas y repetidamente comprobar de ellos en el extremo de cada bucle.

Answer 2

Refactoring es la mejor respuesta, si tiene suficiente complejidad en una función que tiene que salir de dos de estos bucles:

Por ejemplo, este revoltijo de código:

List<List<Item>> listOfLists; 

//Merges lists if they are adjacent until only one is left. 
void MergeAdjacentListsUntilOneIsLeft() 
{ 
    while(listOfLists.Count > 1) 
    { 
     BeginIteration: 
     foreach(List<Item> list in listOfLists) 
     { 
      foreach (Item item in list) 
      { 
       foreach(List<Item> otherList in listOfLists) 
       { 
        if(list.IsAdjacentTo(otherList)) 
        { 
         list.AddRange(otherList); 
         listOfLists.Remove(otherList); 
         goto BeginIteration; 
        } 
       } 
      } 
     } 
    } 
} 

se convierte en:

List<List<Item>> listOfLists; 

//Merges two lists if they are adjacent. 
void MergeIteration() 
{ 
    foreach(List<Item> list in listOfLists) 
    { 
     foreach (Item item in list) 
     { 
      foreach(List<Item> otherList in listOfLists) 
      { 
       if(list.IsAdjacentTo(otherList)) 
       { 
        list.AddRange(otherList); 
        listOfLists.Remove(otherList); 
        return; 
       } 
      } 
     } 
    } 
} 

//Does it until only one is left. 
void MergeAdjacentListsUntilOneIsLeft() 
{ 
    while(listOfLists.Count > 1) 
    { 
     MergeIteration();   
    } 
}