C # में गणना करते समय सूची <T> से आइटम हटाने का बुद्धिमान तरीका

Question 1

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

List<int> myIntCollection = new List<int>();
myIntCollection.Add(42);
myIntCollection.Add(12);
myIntCollection.Add(96);
myIntCollection.Add(25);

foreach (int i in myIntCollection)
{
    if (i == 42)
        myIntCollection.Remove(96);    // The error is here.
    if (i == 25)
        myIntCollection.Remove(42);    // The error is here.
}

परिवर्तन के बाद पुनरावृत्ति की शुरुआत में, एक InvalidOperationExceptionफेंक दिया जाता है, क्योंकि अंतर्निहित संग्रह में परिवर्तन होने पर प्रगणक पसंद नहीं करते हैं।

मुझे पुनरावृत्ति करते हुए संग्रह में परिवर्तन करने की आवश्यकता है। कई पैटर्न हैं जिनका उपयोग इससे बचने के लिए किया जा सकता है , लेकिन उनमें से कोई भी एक अच्छा समाधान नहीं है:

इस लूप के अंदर डिलीट न करें, इसके बजाय एक अलग "डिलीट लिस्ट" रखें, जिसे आप मेन लूप के बाद प्रोसेस करते हैं।

यह आम तौर पर एक अच्छा समाधान है, लेकिन मेरे मामले में, मुझे आइटम को तुरंत "प्रतीक्षा" के रूप में जाने की आवश्यकता है, जब तक कि मुख्य लूप के बाद आइटम वास्तव में मेरे कोड के तर्क प्रवाह को बदल देता है।
आइटम को हटाने के बजाय, बस आइटम पर एक ध्वज सेट करें और इसे निष्क्रिय के रूप में चिह्नित करें। फिर सूची को साफ करने के लिए पैटर्न 1 की कार्यक्षमता जोड़ें।

यह मेरी सभी जरूरतों के लिए काम करेगा , लेकिन इसका मतलब है कि किसी आइटम के एक्सेस होने पर हर बार निष्क्रिय ध्वज की जांच करने के लिए बहुत सारे कोड को बदलना होगा। यह मेरी पसंद के लिए बहुत अधिक प्रशासन है।
किसी तरह पैटर्न 2 के विचारों को एक वर्ग में शामिल किया जाता है जो इससे उत्पन्न होता है List<T>। यह सुपरलिस्ट निष्क्रिय झंडे को संभाल लेगा, इस तथ्य के बाद वस्तुओं का विलोपन होगा और यह भी गणना उपभोक्ताओं के लिए निष्क्रिय के रूप में चिह्नित वस्तुओं को उजागर नहीं करेगा। मूल रूप से, यह सिर्फ पैटर्न 2 (और बाद के पैटर्न 1) के सभी विचारों को कूटबद्ध करता है।

क्या इस तरह एक वर्ग मौजूद है? क्या किसी के पास इसके लिए कोड है? या कोई बेहतर तरीका है?
मुझे बताया गया है कि पहुँच के myIntCollection.ToArray()बजाय myIntCollectionसमस्या का समाधान होगा और मुझे लूप के अंदर हटाने की अनुमति देगा।

यह मेरे लिए एक खराब डिजाइन पैटर्न की तरह लगता है, या शायद यह ठीक है?

विवरण:

सूची में कई आइटम होंगे और मैं उनमें से कुछ को ही हटाऊंगा।
लूप के अंदर, मैं सभी प्रकार की प्रक्रियाएं कर रहा हूं, जोड़ना, निकालना आदि, इसलिए समाधान को काफी सामान्य होने की आवश्यकता है।
जिस आइटम को मुझे हटाने की आवश्यकता है वह लूप में वर्तमान आइटम नहीं हो सकता है। उदाहरण के लिए, मैं 30 आइटम लूप के आइटम 10 पर हो सकता हूं और आइटम 6 या आइटम 26 को हटाने की आवश्यकता हो सकती है। सरणी के माध्यम से पीछे की ओर चलना अब इस वजह से काम नहीं करेगा। ; ओ (

Question 2

सबसे अच्छा समाधान आमतौर पर RemoveAll()विधि का उपयोग करने के लिए है :

myList.RemoveAll(x => x.SomeProp == "SomeValue");

या, यदि आपको हटाए गए कुछ तत्वों की आवश्यकता है:

MyListType[] elems = new[] { elem1, elem2 };
myList.RemoveAll(x => elems.Contains(x));

यह मान लें कि आपका लूप केवल उद्देश्यों को हटाने के उद्देश्य से है। यदि आप ऐसा करने में अतिरिक्त संसाधन की जरूरत है, तो सबसे अच्छा तरीका एक का उपयोग करने के आमतौर पर है forया whileपाश, तब से आप एक प्रगणक उपयोग नहीं कर रहे:

for (int i = myList.Count - 1; i >= 0; i--)
{
    // Do processing here, then...
    if (shouldRemoveCondition)
    {
        myList.RemoveAt(i);
    }
}

पीछे की ओर जाना यह सुनिश्चित करता है कि आप किसी भी तत्व को छोड़ें नहीं।

प्रतिक्रिया के लिए संपादित करें :

यदि आप प्रतीत होता है कि मनमाने ढंग से निकाले गए तत्व हैं, तो सबसे आसान तरीका यह हो सकता है कि जिन तत्वों को आप हटाना चाहते हैं, उन पर नज़र रखें और फिर उन सभी को एक बार में हटा दें। कुछ इस तरह:

List<int> toRemove = new List<int>();
foreach (var elem in myList)
{
    // Do some stuff

    // Check for removal
    if (needToRemoveAnElement)
    {
        toRemove.Add(elem);
    }
}

// Remove everything here
myList.RemoveAll(x => toRemove.Contains(x));

Question 3

यदि आप दोनों को एन्यूमरेट करना चाहिए List<T>और इसे हटा देना चाहिए तो मेरा सुझाव है कि ए के whileबजाय केवल लूप का उपयोग करेंforeach

var index = 0;
while (index < myList.Count) {
  if (someCondition(myList[index])) {
    myList.RemoveAt(index);
  } else {
    index++;
  }
}

Question 4

मुझे पता है कि यह पोस्ट पुरानी है, लेकिन मुझे लगा कि मैं वही काम करूंगा जो मेरे लिए काम करता है।

गणना के लिए सूची की एक प्रति बनाएँ, और फिर प्रत्येक लूप के लिए, आप कॉपी किए गए मानों पर प्रक्रिया कर सकते हैं, और स्रोत सूची के साथ / जो भी हटा / जोड़ सकते हैं।

private void ProcessAndRemove(IList<Item> list)
{
    foreach (var item in list.ToList())
    {
        if (item.DeterminingFactor > 10)
        {
            list.Remove(item);
        }
    }
}

Question 5

जब आपको एक सूची के माध्यम से पुनरावृत्ति करने की आवश्यकता होती है और इसे लूप के दौरान संशोधित किया जा सकता है, तो आप लूप के लिए उपयोग करना बेहतर होता है:

for (int i = 0; i < myIntCollection.Count; i++)
{
    if (myIntCollection[i] == 42)
    {
        myIntCollection.Remove(i);
        i--;
    }
}

बेशक, आपको सावधान रहना चाहिए, उदाहरण के लिए, iजब भी कोई आइटम हटाया जाता है तो मैं इसे घटाता हूं अन्यथा हम प्रविष्टियां छोड़ देंगे (एक विकल्प यह है कि सूची में पीछे की तरफ जाएं)।

अगर आपके पास Linq है तो आपको बस उपयोग करना चाहिए RemoveAllजैसा कि dlev ने सुझाया है।

Question 6

जैसे ही आप सूची में शामिल होते हैं, आप को KEEP में एक नई सूची में जोड़ना चाहते हैं। बाद में, नई सूची को असाइन करेंmyIntCollection

List<int> myIntCollection=new List<int>();
myIntCollection.Add(42);
List<int> newCollection=new List<int>(myIntCollection.Count);

foreach(int i in myIntCollection)
{
    if (i want to delete this)
        ///
    else
        newCollection.Add(i);
}
myIntCollection = newCollection;

Question 7

आइए आपको कोड जोड़ते हैं:

List<int> myIntCollection=new List<int>();
myIntCollection.Add(42);
myIntCollection.Add(12);
myIntCollection.Add(96);
myIntCollection.Add(25);

यदि आप सूची में बदलाव करना चाहते हैं, तो आपको टाइप करना होगा .ToList()

foreach(int i in myIntCollection.ToList())
{
    if (i == 42)
       myIntCollection.Remove(96);
    if (i == 25)
       myIntCollection.Remove(42);
}

Question 8

कैसा रहेगा

int[] tmp = new int[myIntCollection.Count ()];
myIntCollection.CopyTo(tmp);
foreach(int i in tmp)
{
    myIntCollection.Remove(42); //The error is no longer here.
}

Question 9

यदि आप उच्च प्रदर्शन में रुचि रखते हैं, तो आप दो सूचियों का उपयोग कर सकते हैं। निम्नलिखित कचरा संग्रह को कम करता है, मेमोरी लोकलिटी को अधिकतम करता है और वास्तव में कभी भी किसी सूची से कोई आइटम नहीं निकालता है, जो कि अंतिम आइटम नहीं होने पर बहुत अक्षम है।

private void RemoveItems()
{
    _newList.Clear();

    foreach (var item in _list)
    {
        item.Process();
        if (!item.NeedsRemoving())
            _newList.Add(item);
    }

    var swap = _list;
    _list = _newList;
    _newList = swap;
}

Question 10

उन लोगों के लिए जो इसमें मदद कर सकते हैं, मैंने इस एक्सटेंशन विधि को विधेय से मेल खाने वाली वस्तुओं को हटाने और हटाए गए आइटमों की सूची वापस करने के लिए लिखा था।

    public static IList<T> RemoveAllKeepRemoved<T>(this IList<T> source, Predicate<T> predicate)
    {
        IList<T> removed = new List<T>();
        for (int i = source.Count - 1; i >= 0; i--)
        {
            T item = source[i];
            if (predicate(item))
            {
                removed.Add(item);
                source.RemoveAt(i);
            }
        }
        return removed;
    }