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

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

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

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

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

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

我发现自己遇到了类似的情况，我必须删除给定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
}

你不能使用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循环期间删除项。)

在泛型列表上使用ToArray()可以在泛型列表上执行Remove(item):

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

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

如果您不介意在项目的某个地方添加一些代码，您可以向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()的简单性，没有内存开销。

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

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>的典型实现，它将具有线性运行时。