如何在迭代通用列表时从通用列表中删除元素？

Question

我正在寻找一种更好的模式来处理每个需要处理的元素列表，然后根据结果从列表中删除。

您不能在 foreach (X 中的 var element) 中使用 .Remove(element) （因为它会导致 Collection 被修改；枚举操作可能无法执行. 例外）...您也不能使用 for (int i = 0; i < elements.Count(); i++) 和 .RemoveAt(i) 因为它会扰乱您当前在集合中相对于 i 的位置。

有没有一种优雅的方法来做到这一点？

Answer 1

使用 for 循环反向迭代列表：

for (int i = safePendingList.Count - 1; i >= 0; i--)
{
    // some code
    // safePendingList.RemoveAt(i);
}

示例：

var list = new List<int>(Enumerable.Range(1, 10));
for (int i = list.Count - 1; i >= 0; i--)
{
    if (list[i] > 5)
        list.RemoveAt(i);
}
list.ForEach(i => Console.WriteLine(i));

或者，您可以使用 RemoveAll方法 带有要测试的谓词：

safePendingList.RemoveAll(item => item.Value == someValue);

这是一个演示的简化示例：

var list = new List<int>(Enumerable.Range(1, 10));
Console.WriteLine("Before:");
list.ForEach(i => Console.WriteLine(i));
list.RemoveAll(i => i > 5);
Console.WriteLine("After:");
list.ForEach(i => Console.WriteLine(i));

Answer 2

 foreach (var item in list.ToList()) {
     list.Remove(item);
 }

如果您将 .ToList() 添加到列表（或 LINQ 查询的结果），则可以直接从 中删除 item list 没有可怕的 Collection 被修改；枚举操作可能无法执行。 错误。编译器会生成 list 的副本，以便您可以安全地对数组进行删除。

虽然这种模式不是非常有效，但它具有自然的感觉，并且足够灵活，适合几乎任何情况。例如，当您希望将每个item保存到数据库中，并仅在数据库保存成功时将其从list中删除。

Answer 3

一个简单直接的解决方案：

使用在集合上向后运行的标准 for 循环和 RemoveAt(i) 来删除元素。

Answer 4

当您想在迭代集合时从集合中删除元素时，首先想到的应该是反向迭代。

幸运的是，有一个比编写 for 循环更优雅的解决方案，因为 for 循环涉及不必要的键入并且容易出错。

ICollection<int> test = new List<int>(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});

foreach (int myInt in test.Reverse<int>())
{
    if (myInt % 2 == 0)
    {
        test.Remove(myInt);
    }
}

Answer 5

选择您想要想要的元素，而不是尝试删除您不想要想要的元素。这比删除元素要容易得多（通常也更有效）。

var newSequence = (from el in list
                   where el.Something || el.AnotherThing < 0
                   select el);

我想将此作为评论发布，以回应下面迈克尔·狄龙留下的评论，但它太长了，而且无论如何在我的回答中可能很有用：

就我个人而言，我永远不会一一删除项目，如果你这样做的话需要删除，然后调用 RemoveAll ，它采用谓词并且仅重新排列内部数组一次，而 Remove 对每个元素执行 Array.Copy 操作你删除。 RemoveAll 效率大大提高。

当您向后迭代列表时，您已经有了要删除的元素的索引，因此调用 RemoveAt 会更有效，因为 Remove 首先遍历列表以找到您要删除的元素的索引，但您已经知道该索引。

总而言之，我认为没有任何理由在 for 循环中调用 Remove 。理想情况下，如果可能的话，使用上面的代码根据需要从列表中传输元素，这样就根本不需要创建第二个数据结构。

Answer 6

在通用列表上使用 ToArray() 允许您在通用列表上执行删除（项目）：

        List<String> strings = new List<string>() { "a", "b", "c", "d" };
        foreach (string s in strings.ToArray())
        {
            if (s == "b")
                strings.Remove(s);
        }

Answer 7

使用 .ToList() 将复制您的列表，如本问题所述：
ToList()--它会创建一个新列表吗？

通过使用ToList()，您可以从原始列表中删除，因为您实际上是在迭代副本。

foreach (var item in listTracked.ToList()) {    

        if (DetermineIfRequiresRemoval(item)) {
            listTracked.Remove(item)
        }

     }

Answer 8

如果确定要删除哪些项目的函数没有副作用并且不会改变项目（它是一个纯函数），一个简单而有效（线性时间）的解决方案是：

list.RemoveAll(condition);

如果有副作用，我会使用类似的东西：

var toRemove = new HashSet<T>();
foreach(var item in items)
{
     ...
     if(condition)
          toRemove.Add(item);
}
items.RemoveAll(toRemove.Contains);

假设哈希值良好，这仍然是线性时间。但由于哈希集，它增加了内存使用量。

最后，如果您的列表只是一个 IList 而不是 List 我建议我的答案 我该如何做这个特殊的 foreach 迭代器？。与许多其他答案的二次运行时相比，在给定 IList 的典型实现的情况下，这将具有线性运行时。

Answer 9

由于任何删除都是在您可以使用的条件下进行的

list.RemoveAll(item => item.Value == someValue);

Answer 10

您不能使用 foreach，但可以在删除项目时向前迭代并管理循环索引变量，如下所示：

for (int i = 0; i < elements.Count; i++)
{
    if (<condition>)
    {
        // Decrement the loop counter to iterate this index again, since later elements will get moved down during the remove operation.
        elements.RemoveAt(i--);
    }
}

请注意，通常所有这些技术都依赖于被迭代的集合的行为。此处显示的技术适用于标准 List(T)。 （很有可能编写自己的集合类和迭代器，确实允许在 foreach 循环期间删除项目。）

Answer 11

List<T> TheList = new List<T>();

TheList.FindAll(element => element.Satisfies(Condition)).ForEach(element => TheList.Remove(element));

Answer 12

For 循环对此来说是一个糟糕的构造。

使用 while

var numbers = new List<int>(Enumerable.Range(1, 3));

while (numbers.Count > 0)
{
    numbers.RemoveAt(0);
}

但是，如果您绝对必须使用 for

var numbers = new List<int>(Enumerable.Range(1, 3));

for (; numbers.Count > 0;)
{
    numbers.RemoveAt(0);
}

或者，这样：

public static class Extensions
{

    public static IList<T> Remove<T>(
        this IList<T> numbers,
        Func<T, bool> predicate)
    {
        numbers.ForEachBackwards(predicate, (n, index) => numbers.RemoveAt(index));
        return numbers;
    }

    public static void ForEachBackwards<T>(
        this IList<T> numbers,
        Func<T, bool> predicate,
        Action<T, int> action)
    {
        for (var i = numbers.Count - 1; i >= 0; i--)
        {
            if (predicate(numbers[i]))
            {
                action(numbers[i], i);
            }
        }
    }
}

用法：

var numbers = new List<int>(Enumerable.Range(1, 10)).Remove((n) => n > 5);

但是，LINQ 已经有 RemoveAll() 来执行此操作

var numbers = new List<int>(Enumerable.Range(1, 10));
numbers.RemoveAll((n) => n > 5);

最后，您可能最好使用 LINQ 的 Where() 来过滤和创建新列表，而不是改变现有列表。不变性通常是好的。

var numbers = new List<int>(Enumerable.Range(1, 10))
    .Where((n) => n <= 5)
    .ToList();

Answer 13

在迭代列表时在列表上使用 Remove 或 RemoveAt 故意变得困难，因为它几乎总是错误的做法。你也许可以通过一些巧妙的技巧让它工作，但速度会非常慢。每次调用Remove时，它都必须扫描整个列表以找到要删除的元素。每次调用 RemoveAt 时，它都必须将后续元素向左移动 1 个位置。因此，任何使用 Remove 或 RemoveAt 的解决方案都需要二次时间，O(n²)。

如果可以的话，使用RemoveAll。否则，以下模式将在线性时间内就地过滤列表，O(n)。

// Create a list to be filtered
IList<int> elements = new List<int>(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
// Filter the list
int kept = 0;
for (int i = 0; i < elements.Count; i++) {
    // Test whether this is an element that we want to keep.
    if (elements[i] % 3 > 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 < elements.Count) elements.RemoveAt(elements.Count-1);

Answer 14

在迭代列表时从列表中删除项目的最佳方法是使用 RemoveAll()。但人们主要担心的是他们必须在循环内做一些复杂的事情和/或有复杂的比较情况。

解决方案是仍然使用 RemoveAll() 但使用以下表示法：

var list = new List<int>(Enumerable.Range(1, 10));
list.RemoveAll(item => 
{
    // 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 > 5;
});

Answer 15

我会从 LINQ 查询中重新分配列表，该查询会过滤掉您不想保留的元素。

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

除非列表非常大，否则执行此操作不会出现明显的性能问题。

Answer 16

假设谓词是元素的布尔属性，如果它为 true，则应删除该元素：

        int i = 0;
        while (i < list.Count())
        {
            if (list[i].predicate == true)
            {
                list.RemoveAt(i);
                continue;
            }
            i++;
        }

Answer 17

在 C# 中，一种简单的方法是标记要删除的列表，然后创建一个新列表进行迭代...

foreach(var item in list.ToList()){if(item.Delete) list.Remove(item);}  

或者更简单地使用 linq...

list.RemoveAll(p=>p.Delete);

但值得考虑其他任务或线程是否可以访问相同的列表在您忙于删除的同时列出，也许可以使用 ConcurrentList 代替。

Answer 18

有一个选项这里没有提到。

如果您不介意在项目中的某处添加一些代码，则可以添加和扩展 List 以返回反向迭代列表的类的实例。

您可以像这样使用它：

foreach (var elem in list.AsReverse())
{
    //Do stuff with elem
    //list.Remove(elem); //Delete it if you want
}

下面是扩展的样子：

public static class ReverseListExtension
{
    public static ReverseList<T> AsReverse<T>(this List<T> list) => new ReverseList<T>(list);

    public class ReverseList<T> : IEnumerable
    {
        List<T> list;
        public ReverseList(List<T> list){ this.list = list; }

        public IEnumerator GetEnumerator()
        {
            for (int i = list.Count - 1; i >= 0; i--)
                yield return list[i];
            yield break;
        }
    }
}

这基本上是没有分配的 list.Reverse() 。

就像一些人提到的那样，您仍然会遇到逐个删除元素的缺点，如果您的列表非常长，那么这里的一些选项会更好。但我认为有人会想要 list.Reverse() 的简单性，而不需要内存开销。

Answer 19

我希望“模式”是这样的：

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

这将使代码与程序员大脑中进行的过程保持一致。

Answer 20

foreach(var item in list.ToList())

{

if(item.Delete) list.Remove(item);

}

只需从第一个列表创建一个全新的列表即可。我说“简单”而不是“正确”，因为创建一个全新的列表可能比以前的方法具有更高的性能（我没有费心进行任何基准测试。）我通常更喜欢这种模式，它在克服问题方面也很有用Linq-To-Entity 限制。

for(i = list.Count()-1;i>=0;i--)

{

item=list[i];

if (item.Delete) list.Remove(item);

}

这种方式使用普通的旧 For 循环向后循环列表。如果集合的大小发生变化，向前执行此操作可能会出现问题，但向后执行应该始终是安全的。

Answer 21

只是想添加我的 2 美分，以防这对任何人有帮助，我遇到了类似的问题，但需要在迭代时从数组列表中删除多个元素。最高票数的答案在很大程度上为我做到了这一点，直到我遇到错误并意识到在某些情况下索引大于数组列表的大小，因为多个元素被删除但循环的索引没有保留的踪迹。我通过一个简单的检查修复了这个问题：

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>= 0; i--){
    if(i>= place_holder.Count){
        i = place_holder.Count-1; 
    }

// some method that removes multiple elements here
}

Answer 22

复制您正在迭代的列表。然后从副本中取出并与原件进行交互。向后运行会令人困惑，并且在并行循环时效果不佳。

var ids = new List<int> { 1, 2, 3, 4 };
var iterableIds = ids.ToList();

Parallel.ForEach(iterableIds, id =>
{
    ids.Remove(id);
});

Answer 23

我想要这个

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<Author>()
        {
            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 => isEven(item.no));

        foreach(var auth in authorsList)
        {
            Console.WriteLine(auth.Firstname + " " + auth.Lastname);
        }
    }
}

输出

Fred Jones
Billy TheKid

Answer 24

我发现自己处于类似的情况，我必须删除给定 List 中的每个第 n^th 元素。

for (int i = 0, j = 0, n = 3; i < 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
}

Answer 25

从列表中删除一项的成本与要删除的项之后的项数成正比。在前一半项目符合删除条件的情况下，任何基于单独删除项目的方法最终都必须执行大约 N*N/4 项目复制操作，如果列表很大，这可能会变得非常昂贵。

更快的方法是扫描列表以找到第一个要删除的项目（如果有），然后从该点开始将应保留的每个项目复制到其所属的位置。完成此操作后，如果应保留 R 个项目，则列表中的前 R 个项目将是这 R 个项目，所有需要删除的项目将位于末尾。如果以相反的顺序删除这些项目，系统最终将不必复制它们中的任何一个，因此，如果列表有 N 个项目，其中 R 个项目（包括所有前 F 个项目）被保留，
需要复制 RF 项，并将列表缩小 NR 倍一项。所有线性时间。

Answer 26

我的方法是首先创建一个索引列表，该列表应该被删除。然后，我循环索引并从初始列表中删除项目。这看起来像这样：

var messageList = ...;
// Restrict your list to certain criteria
var customMessageList = messageList.FindAll(m => m.UserId == someId);

if (customMessageList != null && customMessageList.Count > 0)
{
    // Create list with positions in origin list
    List<int> positionList = new List<int>();
    foreach (var message in customMessageList)
    {
        var position = messageList.FindIndex(m => 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 => p).ToList();
    foreach (var position in positionList)
    {
        messageList.RemoveAt(position);
    }
}

Answer 27

用属性追踪要移除的元素，处理后将其全部移除。

using System.Linq;

List<MyProperty> _Group = new List<MyProperty>();
// ... add elements

bool cond = false;
foreach (MyProperty currObj in _Group)
{
    // here it is supposed that you decide the "remove conditions"...
    cond = true; // set true or false...
    if (cond) 
    {
        // SET - element can be deleted
        currObj.REMOVE_ME = true;
    }
}
// RESET
_Group.RemoveAll(r => r.REMOVE_ME);

Answer 28

myList.RemoveAt(i--);

simples;