使用.ToList()将创建一个列表的副本，正如这个问题中所解释的: ToList()—它是否创建一个新列表?

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

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

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

     }

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

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

只是想添加我的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
}

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

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

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

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

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

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

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

我会这样做

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