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

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

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

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

因为任何移除都是在你可以使用的条件下进行的

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

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

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

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

只是想添加我的2美分，以防这有助于任何人，我有一个类似的问题，但需要从一个数组列表中删除多个元素，而它正在被迭代。最高的upvotes的答案在很大程度上为我做了，直到我遇到错误，意识到在某些情况下，索引大于数组列表的大小，因为多个元素被删除，但循环的索引没有跟踪它。我用一个简单的检查解决了这个问题:

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
}

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

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