वहाँ सी # में जावा के लेबल को तोड़ने या एक समाधान

Question

मैं सी # करने के लिए कुछ जावा कोड परिवर्तित कर रहा हूँ और पाया है की एक बराबर है कुछ लेबल "तोड़" बयान (जैसे)

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

वहाँ सी # में एक बराबर है (वर्तमान पढ़ने नहीं चलता है) और यदि नहीं वहाँ किसी भी रूपांतरण (कहते हैं) होने bool झंडे के अलावा अन्य है कि प्रत्येक पाश अंत में तोड़ने के लिए इंगित करने के लिए है (उदाहरण के लिए)

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

मैं क्यों सी # नहीं करता है के रूप में रुचि होगी ऐसा नहीं है क्योंकि यह बहुत बुरा नहीं लगता है।

Answer 1

तुम बस goto का उपयोग एक लेबल पर प्रत्यक्ष रूप से कर सकते हैं।

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

सी जैसी भाषाओं में, goto अक्सर, नेस्टेड छोरों को तोड़ने के रूप में बूलियन चर का ट्रैक रखने और बार-बार उन्हें एक पाश के अंत में जाँच करने के लिए विरोध के लिए क्लीनर समाप्त होता है।

Answer 2

पुनर्रचना, सबसे अच्छा जवाब है कि यदि आप एक समारोह में काफी जटिलता है कि आप इस तरह के दो छोरों से बाहर तोड़ करने की जरूरत है:

उदाहरण के लिए कोड के इस गड़बड़ी:

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

बन जाता है:

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