选择您确实需要的元素，而不是试图删除您不想要的元素。这比删除元素要容易得多(通常也更有效)。

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

我想把这篇评论作为对Michael Dillon下面评论的回应，但它太长了，可能在我的回答中有用:

就我个人而言，我从来不会一个接一个地删除项，如果你确实需要删除，那么调用RemoveAll，它接受一个谓词，只重新排列一次内部数组，而remove则是一个数组。为您删除的每个元素复制操作。RemoveAll大大提高了效率。

当你在一个列表上向后迭代时，你已经有了你想要删除的元素的索引，所以调用RemoveAt会更有效，因为remove首先遍历列表来找到你想要删除的元素的索引，但你已经知道那个索引。

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

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

如果你将".ToList()"添加到列表(或LINQ查询的结果)中，你可以直接从"list"中删除"item"，而不用担心"Collection was modified;枚举操作不能执行"错误。编译器会复制“list”，这样你就可以安全地删除数组了。

虽然这种模式不是超级高效，但它有一种自然的感觉，并且对于几乎任何情况都足够灵活。例如，当您想要将每个“项”保存到一个DB，并仅当DB保存成功时才将其从列表中删除。

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

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

除非列表非常大，否则这样做应该不会有明显的性能问题。

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²).

如果可以，使用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);

从列表中删除一个项的成本与后面要删除的项的数量成正比。在前半部分的条目符合删除条件的情况下，任何基于单独删除条目的方法最终都将不得不执行大约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.

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

幸运的是，有一个比编写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);
    }
}