c'è un equivalente di rottura con l'etichetta di Java in C# o una soluzione

Question

Io sono la conversione del codice Java in C# e hanno trovato alcune affermazioni etichettati "break" (ad esempio)

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

Esiste un equivalente in C# (lettura attuale non suggerisce) e se non v'è alcuna conversione diverso (diciamo) con bandiere bool per indicare se per rompere ad ogni estremità ad anello (per esempio)

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

sarei interessato sul motivo per cui C# doesn ce l'ho perché non sembra essere molto malvagio.

Answer 1

È possibile utilizzare semplicemente goto per passare direttamente a un'etichetta.

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

Nei linguaggi C-like, goto spesso finisce pulitore per rompere cicli annidati, al contrario di tenere traccia delle variabili booleane e ripetutamente verifica alla fine di ogni ciclo.

Answer 2

refactoring è la migliore risposta, se avete abbastanza complessità in una funzione che è necessario uscire da due di questi cicli:

Per esempio, questo miscuglio di codice:

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; 
        } 
       } 
      } 
     } 
    } 
} 

diventa:

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();   
    } 
}