How to remove elements from a generic list while iterating over it

Question

I am looking for a better pattern for working with a list of elements which each need processed and then depending on the outcome are removed from the list    You can t use  Remove element  inside a foreach  var element in X   because it results in Collection was modified  enumeration operation may not execute  exception     you also can t use for  int i   0  i  lt  elements Count    i    and  RemoveAt i  because it disrupts your current position in the collection relative to i   Is there an elegant way to do this

User · Answer

I would reassign the list from a LINQ query that filtered out the elements you didn't want to keep.

list = list.Where(item => ...).ToList();

Unless the list is very large there should be no significant performance problems in doing this.

User · Answer

Trace the elements to be removed with a property  and remove them all after process   using System Linq   List lt MyProperty gt   Group   new List lt MyProperty gt            add elements  bool cond   true  foreach  MyProperty currObj in  Group        if  cond                    SET - element can be deleted         currObj REMOVE ME   true             RESET  Group RemoveAll r   gt  r REMOVE ME

User · Answer

Just wanted to add my 2 cents to this in case this helps anyone  I had a similar problem but needed to remove multiple elements from an array list while it was being iterated over  the highest upvoted answer did it for me for the most part until I ran into errors and realized that the index was greater than the size of the array list in some instances because multiple elements were being removed but the index of the loop didn t keep track of that  I fixed this with a simple check    ArrayList place holder   new ArrayList    place holder Add  1    place holder Add  2    place holder Add  3    place holder Add  4     for int i   place holder Count-1  i gt   0  i--       if i gt   place holder Count           i   place holder Count-1             some method that removes multiple elements here

User · Answer

A simple and straightforward solution   Use a standard for-loop running backwards on your collection and RemoveAt i  to remove elements

User · Answer

List lt T gt  TheList   new List lt T gt      TheList FindAll element   gt  element Satisfies Condition   ForEach element   gt  TheList Remove element

User · Answer

I found myself in a similar situation where I had to remove every nth element in a given List lt T gt    for  int i   0  j   0  n   3  i  lt  list Count  i          if   j   1    n    0    Check current iteration is at the nth interval               list RemoveAt i           j      This extra addition is necessary  Without it j will wrap                down to zero  which will throw off our index            j      This will always advance the j counter

User · Answer

myList RemoveAt i--    simples

User · Answer

Copy the list you are iterating  Then remove from the copy and interate the original  Going backwards is confusing and doesn t work well when looping in parallel   var ids   new List lt int gt    1  2  3  4    var iterableIds   ids ToList     Parallel ForEach iterableIds  id   gt        ids Remove id

User · Answer

The cost of removing an item from the list is proportional to the number of items following the one to be removed   In the case where the first half of the items qualify for removal  any approach which is based upon removing items individually will end up having to perform about N N 4 item-copy operations  which can get very expensive if the list is large   A faster approach is to scan through the list to find the first item to be removed  if any   and then from that point forward copy each item which should be retained to the spot where it belongs   Once this is done  if R items should be retained  the first R items in the list will be those R items  and all of the items requiring deletion will be at the end   If those items are deleted in reverse order  the system won t end up having to copy any of them  so if the list had N items of which R items  including all of the first F  were retained  it will be necessary to copy R-F items  and shrink the list by one item N-R times   All linear time

User · Answer

The best way to remove items from a list while iterating over it is to use RemoveAll    But the main concern written by people is that they have to do some complex things inside the loop and or have complex compare cases    The solution is to still use RemoveAll   but use this notation   var list   new List lt int gt  Enumerable Range 1  10    list RemoveAll item   gt            Do some complex operations here        Or even some operations on the items     SomeFunction item          In the end return true if the item is to be removed  False otherwise     return item  gt  5

User · Answer

Using  ToList   will make a  copy of your list  as explained in this question  ToList  -- Does it Create a New List   By using ToList    you can remove from your original list  because you re actually iterating over a copy   foreach  var item in listTracked ToList                   if  DetermineIfRequiresRemoval item                 listTracked Remove item

User · Answer

In C  one easy way is to mark the ones you wish to delete then create a new list to iterate over     foreach var item in list ToList    if item Delete  list Remove item        or even simpler use linq      list RemoveAll p  gt p Delete     but it is worth considering if other tasks or threads will have access to the same list at the same time you are busy removing  and maybe use a ConcurrentList instead

User · Answer

Select the elements you do want rather than trying to remove the elements you don t want  This is so much easier  and generally more efficient too  than removing elements    var newSequence    from el in list                    where el Something    el AnotherThing  lt  0                    select el     I wanted to post this as a comment in response to the comment left by Michael Dillon below  but it s too long and probably useful to have in my answer anyway   Personally  I d never remove items one-by-one  if you do need removal  then call RemoveAll which takes a predicate and only rearranges the internal array once  whereas Remove does an Array Copy operation for every element you remove  RemoveAll is vastly more efficient    And when you re backwards iterating over a list  you already have the index of the element you want to remove  so it would be far more efficient to call RemoveAt  because Remove first does a traversal of the list to find the index of the element you re trying to remove  but you already know that index    So all in all  I don t see any reason to ever call Remove in a for-loop  And ideally  if it is at all possible  use the above code to stream elements from the list as needed so no second data structure has to be created at all

User · Answer

Iterate your list in reverse with a for loop   for  int i   safePendingList Count - 1  i  gt   0  i--           some code        safePendingList RemoveAt i       Example   var list   new List lt int gt  Enumerable Range 1  10    for  int i   list Count - 1  i  gt   0  i--        if  list i   gt  5          list RemoveAt i     list ForEach i   gt  Console WriteLine i      Alternately  you can use the RemoveAll method with a predicate to test against   safePendingList RemoveAll item   gt  item Value    someValue     Here s a simplified example to demonstrate   var list   new List lt int gt  Enumerable Range 1  10    Console WriteLine  Before     list ForEach i   gt  Console WriteLine i    list RemoveAll i   gt  i  gt  5   Console WriteLine  After     list ForEach i   gt  Console WriteLine i

User · Answer

By assuming that predicate is a Boolean property of an element  that if it is true  then the element should be removed           int i   0          while  i  lt  list Count                          if  list i  predicate    true                                list RemoveAt i                   continue                            i

User · Answer

I would do like this   using System IO  using System  using System Collections Generic   class Author               public string Firstname          public string Lastname          public int no         class Program       private static bool isEven int i                  return   i   2     0                static void Main                     var authorsList   new List lt Author gt                          new Author  Firstname    Bob   Lastname    Smith   no   2                new Author  Firstname    Fred   Lastname    Jones   no   3                new Author  Firstname    Brian   Lastname    Brains   no   4                new Author  Firstname    Billy   Lastname    TheKid   no   1                       authorsList RemoveAll item   gt  isEven item no             foreach var auth in authorsList                        Console WriteLine auth Firstname         auth Lastname                       OUTPUT   Fred Jones Billy TheKid

User · Answer

There is an option that hasn t been mentioned here  If you don t mind adding a bit of code somewhere in your project  you can add and extension to List to return an instance of a class that does iterate through the list in reverse  You would use it like this   foreach  var elem in list AsReverse            Do stuff with elem       list Remove elem     Delete it if you want    And here is what the extension looks like  public static class ReverseListExtension       public static ReverseList lt T gt  AsReverse lt T gt  this List lt T gt  list    gt  new ReverseList lt T gt  list        public class ReverseList lt T gt    IEnumerable               List lt T gt  list          public ReverseList List lt T gt  list   this list   list             public IEnumerator GetEnumerator                         for  int i   list Count - 1  i  gt   0  i--                  yield return list i               yield break                     This is basically list Reverse   without the allocation  Like some have mentioned you still get the drawback of deleting elements one by one  and if your list is massively long some of the options here are better  But I think there is a world where someone would want the simplicity of list Reverse    without the memory overhead

User · Answer

I wish the  pattern  was something like this   foreach  thing in thingpile         if     condition 1                    foreach markfordeleting  thing              elseif     condition 2                    foreach markforkeeping  thing             foreachcompleted          then the programmer s choices would be          delete everything that was marked for deleting     foreach deletenow thingpile               or    keep only things that were marked for keeping     foreach keepnow thingpile              or even    make a new list of the unmarked items     others   foreach unmarked thingpile          This would align the code with the process that goes on in the programmer s brain

User · Answer

For loops are a bad construct for this  Using while var numbers   new List lt int gt  Enumerable Range 1  3     while  numbers Count  gt  0        numbers RemoveAt 0      But  if you absolutely must use for var numbers   new List lt int gt  Enumerable Range 1  3     for    numbers Count  gt  0         numbers RemoveAt 0      Or  this  public static class Extensions        public static IList lt T gt  Remove lt T gt           this IList lt T gt  numbers          Func lt T  bool gt  predicate                numbers ForEachBackwards predicate   n  index    gt  numbers RemoveAt index            return numbers             public static void ForEachBackwards lt T gt           this IList lt T gt  numbers          Func lt T  bool gt  predicate          Action lt T  int gt  action                for  var i   numbers Count - 1  i  gt   0  i--                        if  predicate numbers i                                  action numbers i   i                                    Usage  var numbers   new List lt int gt  Enumerable Range 1  10   Remove  n    gt  n  gt  5

User · Answer

You can t use foreach  but you could iterate forwards and manage your loop index variable when you remove an item  like so   for  int i   0  i  lt  elements Count  i          if   lt condition gt                    Decrement the loop counter to iterate this index again  since later elements will get moved down during the remove operation          elements RemoveAt i--             Note that in general all of these techniques rely on the behaviour of the collection being iterated  The technique shown here will work with the standard List T    It is quite possible to write your own collection class and iterator that does allow item removal during a foreach loop

User · Answer

If the function that determines which items to delete has no side effects and doesn t mutate the item  it s a pure function   a simple and efficient  linear time  solution is   list RemoveAll condition     If there are side effects  I d use something like   var toRemove   new HashSet lt T gt     foreach var item in items                  if condition            toRemove Add item     items RemoveAll toRemove Contains     This is still linear time  assuming the hash is good  But it has an increased memory use due to the hashset   Finally if your list is only an IList lt T gt  instead of a List lt T gt  I suggest my answer to How can I do this special foreach iterator   This will have linear runtime given typical implementations of IList lt T gt   compared with quadratic runtime of many other answers

User · Answer

foreach var item in list ToList        if item Delete  list Remove item        Simply create an entirely new list from the first one  I say  Easy  rather than  Right  as creating an entirely new list probably comes at a performance premium over the previous method  I haven t bothered with any benchmarking   I generally prefer this pattern  it can also be useful in overcoming Linq-To-Entities limitations   for i   list Count  -1 i gt  0 i--      item list i    if  item Delete  list Remove item        This way cycles through the list backwards with a plain old For loop  Doing this forwards could be problematic if the size of the collection changes  but backwards should always be safe

User · Answer

Using the ToArray   on a generic list allows you to do a Remove item  on your generic List           List lt String gt  strings   new List lt string gt       a    b    c    d             foreach  string s in strings ToArray                          if  s     b                   strings Remove s

User · Answer

As any remove is taken on a condition you can use  list RemoveAll item   gt  item Value    someValue

User · Answer

Using Remove or RemoveAt on a list while iterating over that list has intentionally been made difficult  because it is almost always the wrong thing to do  You might be able to get it working with some clever trick  but it would be extremely slow  Every time you call Remove it has to scan through the entire list to find the element you want to remove  Every time you call RemoveAt it has to move subsequent elements 1 position to the left  As such  any solution using Remove or RemoveAt  would require quadratic time  O n      Use RemoveAll if you can  Otherwise  the following pattern will filter the list in-place in linear time  O n       Create a list to be filtered IList lt int gt  elements   new List lt int gt  new int    1  2  3  4  5  6  7  8  9  10       Filter the list int kept   0  for  int i   0  i  lt  elements Count  i             Test whether this is an element that we want to keep      if  elements i    3  gt  0               Add it to the list of kept elements          elements kept    elements i           kept               Unfortunately IList has no Resize method  So instead we    remove the last element of the list until  elements Count    kept  while  kept  lt  elements Count  elements RemoveAt elements Count-1

User · Answer

Reverse iteration should be the first thing to come to mind when you want to remove elements from a Collection while iterating over it   Luckily  there is a more elegant solution than writing a for loop which involves needless typing and can be error prone   ICollection lt int gt  test   new List lt int gt  new int    1  2  3  4  5  6  7  8  9  10     foreach  int myInt in test Reverse lt int gt           if  myInt   2    0                test Remove myInt

User · Answer

My approach is that I first create a list of indices  which should get deleted  Afterwards I loop over the indices and remove the items from the initial list  This looks like this   var messageList           Restrict your list to certain criteria var customMessageList   messageList FindAll m   gt  m UserId    someId    if  customMessageList    null  amp  amp  customMessageList Count  gt  0           Create list with positions in origin list     List lt int gt  positionList   new List lt int gt         foreach  var message in customMessageList                var position   messageList FindIndex m   gt  m MessageId    message MessageId           if  position    -1              positionList Add position                To be able to remove the items in the origin list  we do it backwards        so that the order of indices stays the same     positionList   positionList OrderByDescending p   gt  p  ToList        foreach  var position in positionList                messageList RemoveAt position

User · Answer

foreach  var item in list ToList           list Remove item        If you add   ToList    to your list  or the results of a LINQ query   you can remove  item  directly from  list  without the dreaded  Collection was modified  enumeration operation may not execute   error  The compiler makes a copy of  list   so that you can safely do the remove on the array    While this pattern is not super efficient  it has a natural feel and is flexible enough for almost any situation  Such as when you want to save each  item  to a DB and remove it from the list only when the DB save succeeds

[c#] How to remove elements from a generic list while iterating over it?

Examples related to c#

Examples related to list

Examples related to loops

Examples related to generics

Examples related to key-value