要认识到的最重要的一点是，使用Linq时，查询不会立即得到求值。它只是作为在foreach中迭代生成的IEnumerable＜T＞的一部分运行的，这是所有奇怪的代理都在做的。

因此，第一个示例通过调用ToList并将查询结果放在列表中来立即评估查询。第二个示例返回一个IEnumerable＜T＞，其中包含稍后运行查询所需的所有信息。

就性能而言，答案是这取决于。如果您需要立即评估结果（例如，您正在改变稍后查询的结构，或者如果您不希望IEnumerable＜t＞上的迭代需要很长时间），请使用列表。否则使用IEnumerable＜T＞。默认情况下，在第二个示例中应使用按需评估，因为这通常使用较少的内存，除非有特定原因将结果存储在列表中。

如果您只想枚举它们，请使用IEnumerable。

不过，请注意，更改正在枚举的原始集合是一个危险的操作——在这种情况下，您将需要首先ToList。这将为内存中的每个元素创建一个新的列表元素，枚举IEnumerable，因此如果只枚举一次，性能会降低-但更安全，有时list方法很方便（例如在随机访问中）。

IEnumerable的优点是延迟执行（通常与数据库一起执行）。在实际循环数据之前，不会执行查询。这是一个等待需要的查询（也称为延迟加载）。

如果您调用ToList，查询将被执行，或者如我所说的“物化”。

两者都有利弊。如果调用ToList，则可以消除查询何时执行的一些神秘性。如果你坚持IEnumerable，你会得到这样的好处，即程序在实际需要之前不会做任何工作。

实现IEnumerable的类允许您使用foreach语法。

基本上，它有一个获取集合中下一个项的方法。它不需要将整个集合存储在内存中，也不知道其中有多少项，foreach只需要不断获取下一项，直到用完为止。

这在某些情况下非常有用，例如在大型数据库表中，您不希望在开始处理行之前将整个内容复制到内存中。

现在List实现IEnumerable，但表示内存中的整个集合。如果您有一个IEnumerable，并调用.ToList（），则会在内存中创建一个包含枚举内容的新列表。

linq表达式返回一个枚举，默认情况下，当您使用foreach遍历时，该表达式将执行。迭代foreach时执行IEnumerable linq语句，但可以使用.ToList（）强制其更快地迭代。

我的意思是：

var things = 
    from item in BigDatabaseCall()
    where ....
    select item;

// this will iterate through the entire linq statement:
int count = things.Count();

// this will stop after iterating the first one, but will execute the linq again
bool hasAnyRecs = things.Any();

// this will execute the linq statement *again*
foreach( var thing in things ) ...

// this will copy the results to a list in memory
var list = things.ToList()

// this won't iterate through again, the list knows how many items are in it
int count2 = list.Count();

// this won't execute the linq statement - we have it copied to the list
foreach( var thing in list ) ...

IEnumerable描述行为，而List是该行为的实现。当您使用IEnumerable时，您给编译器一个机会，将工作推迟到以后，可能会在这一过程中进行优化。如果使用ToList（），则强制编译器立即将结果具体化。

每当我“堆叠”LINQ表达式时，我都会使用IEnumerable，因为通过只指定行为，我给了LINQ一个延迟求值并可能优化程序的机会。还记得LINQ如何在枚举数据库之前不生成SQL来查询数据库吗？考虑一下：

public IEnumerable<Animals> AllSpotted()
{
    return from a in Zoo.Animals
           where a.coat.HasSpots == true
           select a;
}

public IEnumerable<Animals> Feline(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Felidae"
           select a;
}

public IEnumerable<Animals> Canine(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Canidae"
           select a;
}

现在您有了一个选择初始样本（“AllSpoted”）的方法，以及一些过滤器。现在你可以这样做了：

var Leopards = Feline(AllSpotted());
var Hyenas = Canine(AllSpotted());

那么，使用List比IEnumerable更快吗？仅当您希望防止查询被多次执行时。但总体而言，情况是否更好？在上面的例子中，Leopards和Hyenas分别被转换为单个SQL查询，数据库只返回相关的行。但是，如果我们从AllSpotted（）返回了一个List，那么它可能会运行得更慢，因为数据库可能会返回比实际需要的数据多得多的数据，而且我们在客户端进行过滤会浪费时间。

在程序中，最好将查询转换为列表，直到最后，所以如果我要多次枚举Leopards和Hyenas，我会这样做：

List<Animals> Leopards = Feline(AllSpotted()).ToList();
List<Animals> Hyenas = Canine(AllSpotted()).ToList();

没有人提到一个关键的区别，讽刺的是，在一个问题上，答案是重复的。

IEnumerable是只读的，而List不是。

参见List和IEnumerable之间的实际差异

这里有一篇很好的文章：Claudio Bernasconi的TechBlog：何时使用IEnumerable、ICollection、IList和List

以下是一些关于场景和功能的基本要点：

我将分享一个被误用的概念：

var names = new List<string> {"mercedes", "mazda", "bmw", "fiat", "ferrari"};

var startingWith_M = names.Where(x => x.StartsWith("m"));

var startingWith_F = names.Where(x => x.StartsWith("f"));


// updating existing list
names[0] = "ford";

// Guess what should be printed before continuing
print( startingWith_M.ToList() );
print( startingWith_F.ToList() );

预期结果

// I was expecting    
print( startingWith_M.ToList() ); // mercedes, mazda
print( startingWith_F.ToList() ); // fiat, ferrari

实际结果

// what printed actualy   
print( startingWith_M.ToList() ); // mazda
print( startingWith_F.ToList() ); // ford, fiat, ferrari

解释

根据其他答案，结果的评估被推迟到调用ToList或类似的调用方法（例如ToArray）。

因此，我可以将这种情况下的代码重写为：

var names = new List<string> {"mercedes", "mazda", "bmw", "fiat", "ferrari"};

// updating existing list
names[0] = "ford";

// before calling ToList directly
var startingWith_M = names.Where(x => x.StartsWith("m"));

var startingWith_F = names.Where(x => x.StartsWith("f"));

print( startingWith_M.ToList() );
print( startingWith_F.ToList() );

在附近玩耍

https://repl.it/E8Ki/0

除了上面贴出的所有答案，这是我的两分钱。除List之外，还有许多其他类型实现IEnumerable，如ICollection、ArrayList等。因此，如果我们将IEnumeraable作为任何方法的参数，我们可以将任何集合类型传递给函数。也就是说，我们可以有方法来操作抽象，而不是任何特定的实现。

在许多情况下（例如无限列表或非常大的列表），IEnumerable无法转换为list。最明显的例子是所有的质数，facebook的所有用户及其详细信息，或者ebay上的所有项目。

不同之处在于，“List”对象“就在此时此地”存储，而“IEnumerable”对象“一次只能存储一个”。所以，如果我在ebay上浏览所有项目，一次一个，即使是一台小型计算机也能处理，但“.ToList（）”肯定会耗尽我的内存，无论我的计算机有多大。没有一台计算机能够单独包含和处理如此庞大的数据量。

[编辑]-不用说-这不是“这个或那个”。通常，在同一类中同时使用列表和IEnumerable是很有意义的。世界上没有一台计算机能列出所有素数，因为根据定义，这需要无限的内存。但是您可以很容易地想到一个类PrimeContainer，它包含IEnumerable＜long＞素数，由于明显的原因，它还包含SortedList＜long＜_primes。迄今为止计算的所有素数。要检查的下一个素数将只针对现有素数运行（直到平方根）。通过这种方式，您可以同时获得一个素数（IEnumerable）和一个很好的“迄今为止的素数”列表，这是整个（无限）列表的很好的近似值。

IEnumerable（延迟执行）的缺点是，在调用.ToList（）之前，列表可能会发生更改。举一个非常简单的例子，这是可行的

var persons;
using (MyEntities db = new MyEntities()) {
    persons = db.Persons.ToList(); // It's mine now. In the memory
}
// do what you want with the list of persons;

这是行不通的

IEnumerable<Person> persons;
 using (MyEntities db = new MyEntities()) {
     persons = db.Persons; // nothing is brought until you use it;
 }

persons = persons.ToList();  // trying to use it...
// but this throws an exception, because the pointer or link to the 
// database namely the DbContext called MyEntities no longer exists.