कुशलतापूर्वक 'foreach'

Question

अभी के लिए भीतर से आइटम को हटाने, सबसे अच्छा मैं के बारे में सोच सकता है:

bool oneMoreTime = true; 
while (oneMoreTime) 
{ 
    ItemType toDelete=null; 
    oneMoreTime=false; 
    foreach (ItemType item in collection) 
    { 
     if (ShouldBeDeleted(item)) 
     { 
      toDelete=item; 
      break; 
     } 
    } 
    if (toDelete!=null) 
    { 
     collection.Remove(toDelete); 
     oneMoreTime=true; 
    } 
} 

मैं जानता हूँ कि मैं कम से कम एक अतिरिक्त चर यहाँ है, लेकिन मैं इसे शामिल की पठनीयता में सुधार करने के लिए एल्गोरिदम।

Answer 1

"RemoveAll" विधि सर्वोत्तम है।

एक अन्य आम तकनीक है:

var itemsToBeDeleted = collection.Where(i=>ShouldBeDeleted(i)).ToList(); 
foreach(var itemToBeDeleted in itemsToBeDeleted) 
    collection.Remove(itemToBeDeleted); 

एक अन्य आम तकनीक पाश "के लिए" एक का उपयोग करने के लिए, लेकिन यकीन है कि तुम जाओ बनाने है पीछे की ओर:

for (int i = collection.Count - 1; i >= 0; --i) 
    if (ShouldBeDeleted(collection[i])) 
     collection.RemoveAt(i); 

एक अन्य आम तकनीक को जोड़ने के लिए है आइटम जो नए संग्रह में हटाए जा रहे हैं:

var newCollection = new List<whatever>(); 
foreach(var item in collection.Where(i=>!ShouldBeDeleted(i)) 
    newCollection.Add(item); 

और अब आपके पास दो संग्रह हैं। एक तकनीक जिसे मैं विशेष रूप से पसंद करता हूं यदि आप दो संग्रहों के साथ समाप्त करना चाहते हैं तो अपरिवर्तनीय डेटा संरचनाओं का उपयोग करना है। एक अपरिवर्तनीय डेटा संरचना के साथ, किसी आइटम को "निकालना" डेटा संरचना को नहीं बदलता है; यह आपको एक नई डेटा संरचना देता है (यदि संभव हो तो पुराने से बिट्स का पुन: उपयोग करता है) जिसमें आपके द्वारा निकाली गई वस्तु नहीं है। अपरिवर्तनीय डेटा संरचनाओं के साथ आप बात तुम पर पुनरावृत्ति कर रहे हैं संशोधित कर रहे हैं नहीं, इसलिए कोई समस्या नहीं है:

var newCollection = oldCollection; 
foreach(var item in oldCollection.Where(i=>ShouldBeDeleted(i)) 
    newCollection = newCollection.Remove(item); 

या

var newCollection = ImmutableCollection<whatever>.Empty; 
foreach(var item in oldCollection.Where(i=>!ShouldBeDeleted(i)) 
    newCollection = newCollection.Add(item); 

और जब आप पूरा कर लें, आप दो संग्रह है। नए आइटम को हटा दिया गया है, पुराना एक जैसा ही था।

Answer 2

जैसे ही मैंने टाइपिंग समाप्त की, मुझे याद आया कि ऐसा करने के लिए लैम्ब्डा-तरीका है।

collection.RemoveAll(i=>ShouldBeDeleted(i)); 

बेहतर तरीका?

Answer 3

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

for (int i = collection.Count-1; i >= 0; i--) 
{ 
    if(ShouldBeDeleted(collection[i]) 
     collection.RemoveAt(i); 
} 

मुझे लगता है कि संग्रह संभालने हूँ एक ArrayList यहाँ है, कोड थोड़ी अलग है, तो आप एक अलग डेटा संरचना का उपयोग कर रहे हो सकता है।

Answer 4

आप foreach लूप के अंदर किसी संग्रह से नहीं हटा सकते हैं (जब तक कि यह एक विशेष गणक नहीं है)। संग्रहित होने पर बीसीएल संग्रह अपवाद फेंक देगा अगर गणना की जा रही है।

आप व्यक्तिगत तत्वों को हटाने और तदनुसार इंडेक्स को समायोजित करने के लिए for पाश का उपयोग कर सकते हैं। हालांकि, ऐसा करने से त्रुटि प्रवण हो सकती है। अंतर्निहित संग्रह के कार्यान्वयन के आधार पर व्यक्तिगत तत्वों को हटाना महंगा हो सकता है। उदाहरण के लिए List<T> के पहले तत्व को हटाने से सूची में सभी पुनर्निर्मित तत्वों की प्रतिलिपि बनाई जाएगी।

var newCollection = collection.Where(item => !ShouldBeDeleted(item)).ToList(); 

उपयोग ToList() या ToArray() नया संग्रह बनाने या IEnumerableWhere() खंड द्वारा लौटाए से अपने विशिष्ट संग्रह प्रकार प्रारंभ करने में:

सबसे अच्छा समाधान एक नया संग्रह वर्ष के आधार पर बनाने के लिए अक्सर है।

Answer 5

पिछड़े for पाश पर एक आगे भिन्नता:

for (int i = 0; i < collection.Count;) 
    if (ShouldBeDeleted(collection[i])) 
     collection.RemoveAt(i) 
    else 
     i++; 

Answer 6

बस

प्रथम सूची अपने मूल सूची और दूसरा सूची है दो सूची का उपयोग करें, जो आइटम नहीं निकाला जाना चाहिए के लिए है।

var filteredItems = new List<ItemType>(); 

foreach(var item in collection){ 
    if(!ShouldBeDeleted(item)) 
     filteredItems.Add(item); 
}