IEnumerable vs List-使用什么？它们如何工作？

我对Enumerators和LINQ的工作方式有疑问。考虑以下两个简单选择：

List<Animal> sel = (from animal in Animals 
                    join race in Species
                    on animal.SpeciesKey equals race.SpeciesKey
                    select animal).Distinct().ToList();

要么

IEnumerable<Animal> sel = (from animal in Animals 
                           join race in Species
                           on animal.SpeciesKey equals race.SpeciesKey
                           select animal).Distinct();

我更改了原始对象的名称，以使其看起来像一个更通用的示例。查询本身不是那么重要。我想问的是：

foreach (Animal animal in sel) { /*do stuff*/ }

1. 我注意到，如果我使用IEnumerable，当我调试并检查“ sel”（在这种情况下为IEnumerable）时，它具有一些有趣的成员：“ inner”，“ outer”，“ innerKeySelector”和“ outerKeySelector”，最后两个出现成为代表。“内部”成员中没有“动物”实例，而是“物种”实例，这对我来说很奇怪。“外部”成员确实包含“动物”实例。我假设这两个代表确定哪个进出什么？

2. 我注意到，如果我使用“ Distinct”，则“ inner”包含6个项目（这是不正确的，因为只有2个是Distinct），但是“ outer”确实包含正确的值。同样，可能委托方法确定了这一点，但这比我对IEnumerable的了解还多。

3. 最重要的是，这两个选项中哪个是性能最佳的？

邪恶列表转换通过.ToList()？

还是直接使用枚举器？

如果可以的话，也请稍作解释或抛出一些链接来解释IEnumerable的用法。

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

现在，您有了一个选择初始样本（“ AllSpotted”）以及一些过滤器的方法。现在，您可以执行以下操作：

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

那么使用List over更快IEnumerable吗？仅当您要阻止查询多次执行时。但是总体上更好吗？在上面的代码中，Leopards和Hyenas分别转换为单个SQL查询，并且数据库仅返回相关的行。但是，如果我们从中返回了List AllSpotted()，则它的运行速度可能会变慢，因为数据库返回的数据可能远远超过实际需要的数据，并且浪费了在客户端进行过滤的周期。

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

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

有一篇非常好的文章由：Claudio Bernasconi的TechBlog撰写：何时使用IEnumerable，ICollection，IList和List

这里是有关方案和功能的一些基本知识：

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

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

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

现在List实现IEnumerable，但表示内存中的整个集合。如果您有一个，IEnumerable并且您打电话给.ToList()您，则会使用内存中枚举的内容创建一个新列表。

您的linq表达式返回一个枚举，默认情况下，当您使用进行迭代时，该表达式会执行foreach。一个IEnumerableLINQ语句执行，当你迭代foreach，但是你可以用它迫使迭代更快.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不是。

请参阅List和IEnumerable之间的实际区别

要实现的最重要的事情是，使用Linq，查询不会立即得到评估。它只是在遍历结果的过程IEnumerable<T>中运行的foreach-这就是所有奇怪的代表正在做的事情。

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

就性能而言，答案取决于它。如果您需要一次评估结果（例如，您要对稍后查询的结构进行变异，或者您不希望迭代IEnumerable<T>花费很长时间），请使用列表。否则使用IEnumerable<T>。默认情况下，应该在第二个示例中使用按需评估，因为通常会使用较少的内存，除非出于特殊原因将结果存储在列表中。

IEnumerable的优点是延迟执行（通常使用数据库）。在您实际遍历数据之前，查询将不会执行。这是一个查询，直到需要它为止（又称延迟加载）。

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

两者都有优点和缺点。如果调用ToList，则可以消除执行查询时的神秘性。如果坚持使用IEnumerable，您将获得一个好处，即该程序在实际需要时才起作用。

我将分享一个误入歧途的误解：

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

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

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

除了上面发布的所有答案外，这是我的两分钱。除了List以外，还有许多其他类型可以实现IEnumerable，例如ICollection，ArrayList等。因此，如果我们将IEnumerable作为任何方法的参数，则可以将任何集合类型传递给该函数。也就是说，我们可以有一种方法可以对抽象进行操作，而不需要任何特定的实现。

在许多情况下（例如，无限列表或非常大的列表），IEnumerable无法转换为列表。最明显的例子是所有素数，所有带详细信息的facebook用户或ebay上的所有商品。

区别在于“列表”对象“在此立即存储”，而“ IEnumerable”对象“一次仅存储”。因此，如果我要遍历ebay上的所有项目，即使是一台小型计算机也可以一次处理一次，但是“ .ToList（）”肯定会耗尽我的内存，无论我的计算机有多大。没有计算机本身可以包含和处理如此大量的数据。

[编辑]-不用说-它不是“这个或那个”。通常，在同一类中同时使用列表和IEnumerable是很有意义的。世界上没有计算机可以列出所有素数，因为根据定义，这将需要无限量的内存。但是，您很容易想到class PrimeContainer包含的 IEnumerable<long> primes，出于明显的原因，其中也包含SortedList<long> _primes。到目前为止计算的所有素数。下一个要检查的素数将仅针对现有素数运行（直到平方根）。这样，您既会获得-一次素数（即IEnumerable）又获得了一个很好的“到目前为止素数”列表，这与整个（无限）列表非常相似。