IList vs IEnumerable：当他们“执行”LINQ查询时？

Question

我知道当我调用一些方法时，它会开始执行链接到该集合实例的整个 LINQ 查询。

例如，每次我打电话给.Count()。而且我想每次我打电话给.ToList()。

获得 ToList() 后，我对该集合进行“复制”，如果我不对集合的新实例编写任何 LINQ 查询，Count() 将不会执行任何操作。 （对吧？）

如果我在 2 列表中调用 .Union() 会怎样？并在 2 Ienumerable 上？和.Except()一样吗？

尝试了一些 Trace/Diagnostic，但我无法真正理解何时执行 LINQ 查询。

Answer 1

Union 和 except 被延迟执行。阅读文档中的备注部分了解更多信息。

http://msdn.microsoft.com/en-us/library/bb341731

http://msdn.microsoft.com/en-us/library/bb300779

此外，在这种情况下，当您确定幕后发生的事情时，您可以使用 Reflector 或任何其他 .NET 反编译器。真的很有帮助。

Answer 2

您的问题的答案取决于两个选项：

• 操作类型：懒惰（或延迟）和贪婪。惰性操作不会立即执行，而是延迟到代码开始从您的 linq 源实现数据。贪婪操作总是立即执行。
  • 惰性操作示例：.Union、.Except、.Where、.Select 和大多数其他 linq 操作
  • 贪婪的是：.ToList、.Count .ToArray 以及所有实现数据的操作
• linq 操作的数据来源。当您使用 Linq to Memory 时，所有操作（懒惰和贪婪）都将立即执行。通常，Linq 到外部数据源只会在具体化期间执行惰性操作。

使用这两条规则，您可以预测 linq 的行为方式：

1. .Count 和 .ToList 将立即执行并具体化数据
2. .ToList之后，你会在内存中获取collection，所有后续操作都会立即执行（.Count会再执行一次）
3. .Union 和.Except 将如何表现为惰性或贪婪取决于数据源的类型。对于内存，它们会贪婪，对于 SQL 则很懒。

LinqPad 的示例。在使用贪婪的.Count 或.ToList 实现之前和之后，我有一个Enumerable 和惰性或延迟.Where 和.Select 操作：

void Main() 
{ 
    "get enumerable".Dump(); 
    var samplesEnumerable = GetSamples(); 

    "get count on enumerable #1".Dump(); 
    samplesEnumerable.Count().Dump(); 

    "get enumerable to list #1".Dump();  
    var list = samplesEnumerable.ToList();   

    "get count on list #1".Dump();   
    list.Count().Dump(); 

    "get count on list again #2".Dump(); 
    list.Count().Dump(); 

    "get where/select enumerable #1".Dump(); 
    samplesEnumerable 
        .Where(sample => { sample.Dump(); return sample.Contains("5"); }) 
        .Select(sample => { sample.Dump(); return sample; })
        .Dump(); 

    "get where/select list #1".Dump(); 
    list 
        .Where(sample => { sample.Dump(); return sample.Contains("5"); }) 
        .Select(sample => { sample.Dump(); return sample; })
        .Dump(); 
} 

string[] samples = new [] { "data1", "data2", "data3", "data4", "data5" }; 

IEnumerable<string> GetSamples() 
{ 
    foreach(var sample in samples)  
    { 
        sample.Dump(); 
        yield return sample; 
    } 
}

示例输出。重点

1. 在未具体化的数据上，每个.Count 和.List 都在一次又一次地检索数据

   • get count on enumerable #1
   • get where/select enumerable #1

2. 具体化数据后，将不再检索可枚举

   • get enumerable to list #1
   • get count on list #1
   • get count on list again #2
   • get where/select list #1

输出：

get enumerable
get count on enumerable #1
data1
data2
data3
data4
data5

5
get enumerable to list #1
data1
data2
data3
data4
data5
get count on list #1

5
get count on list again #2

5
get where/select enumerable #1
data1
data1
data2
data2
data3
data3
data4
data4
data5
data5
data5

data5 

get where/select list #1
data1
data2
data3
data4
data5
data5

data5

Answer 3

当一个 Linq 查询有一个基础集合但它是不是一个集合时，它会被执行。例如，您可以使用ToList() 或ToArray 实现查询。

每个延迟执行的Enumerable 扩展首先尝试将IEnumerable<T> 转换为IList<T>（例如，如果它需要索引器）或ICollection<T>（例如，如果它需要Count）。如果可以，则使用不需要执行查询的“native”方法，否则将枚举序列。

在MSDN 上搜索项目deferred 以查看方法是延迟执行还是立即执行。如果您检查源代码（例如通过ILSpy），您可以通过查找yield keyword 来检测延迟执行的方法。

Union 和 Except 是使用延迟执行实现的。所以如果你想保持这个结果，你需要一个ToList/ToArray。

这里是一个例子，Enumerable.Count的实现：

ICollection<TSource> collection = source as ICollection<TSource>;
if (collection != null)
{
    return collection.Count;
}
ICollection collection2 = source as ICollection;
if (collection2 != null)
{
    return collection2.Count;
}
int num = 0;
using (IEnumerator<TSource> enumerator = source.GetEnumerator())
{
    while (enumerator.MoveNext())
    {
        num++;
    }
}
return num;