复制您正在迭代的列表。然后从副本中删除并与原件相互作用。倒退是令人困惑的，并且在并行循环时不能很好地工作。

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

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

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

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

一个简单而直接的解决方案:

在你的集合上使用一个标准的for循环，并使用RemoveAt(i)来删除元素。

如果决定删除哪些项的函数没有副作用，也没有改变项(这是一个纯函数)，一个简单有效的(线性时间)解决方案是:

list.RemoveAll(condition);

如果有副作用，我会使用如下方法:

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

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

最后，如果你的列表只是一个IList<T>，而不是一个list <T>，我建议我的答案，我怎么能做这个特殊的foreach迭代器?与许多其他答案的二次运行时相比，给出IList<T>的典型实现，它将具有线性运行时。

我发现自己遇到了类似的情况，我必须删除给定List<T>中的每n个元素。

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
}

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

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.