为什么这个IEnumerable扩展方法比另一个(更简单的)扩展方法(只迭代输入)慢得多？

Question

我有一个控制台应用程序,包含两个方法:

public static IEnumerable<TSource>
          FooA<TSource>(this IEnumerable<IEnumerable<TSource>> source)
{
    return source.Aggregate((x, y) => x.Intersect(y));
}

public static IEnumerable<TSource> 
          FooB<TSource>(this IEnumerable<IEnumerable<TSource>> source)
{
    foreach (TSource element in source.First())
    {
        yield return element;
    }
}

它的作用:既取序列序列,又FooA生成所有序列的交集,然后返回结果.FooB简单地迭代第一个序列.

我不明白的FooB是FooA:慢了10多倍,而FooB实际上要简单得多(没有调用Intersect()方法).

结果如下:

00:00:00.0071053 (FooA)
00:00:00.0875303 (FooB)

FooB通过直接返回可以快得多source.First(),无论如何我Distinct使用ILSpy 反编译方法并找到完全相同的foreach yield return循环:

private static IEnumerable<TSource> DistinctIterator<TSource>
   (IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
{
    Set<TSource> set = new Set<TSource>(comparer);
    foreach (TSource current in source)
    {
        if (set.Add(current))
        {
            yield return current;
        }
    }
    yield break;
} 

另外:在我使用的代码中我无法返回source.First()(我得到CS1622).我在这里展示的实际上是一个更简单的代码,我为调试而剥离了.

这是我用于测试的代码:

List<List<int>> foo = new List<List<int>>();
foo.Add(new List<int>(Enumerable.Range(0, 3000*1000)));

Stopwatch sa = new Stopwatch();
sa.Start();
List<int> la = FooA(foo).ToList();
Console.WriteLine(sa.Elapsed);


Stopwatch sb = new Stopwatch();
sb.Start();
List<int> lb = FooB(foo).ToList();
Console.WriteLine(sb.Elapsed);  

Answer 1

您测量如此大的差异的原因是Aggregate调用只返回您的初始列表,因为没有要聚合的项目,因为您的列表只有一个项目.

如果你改成它

    List<List<int>> foo = new List<List<int>>()
    {
        new List<int>(Enumerable.Range(0, 3000 * 1000)),
        new List<int>(Enumerable.Range(0, 3000 * 1000)),
    };

只有一件像你一样:

A: 00:00:00.0037843
B: 00:00:00.0514177

但有两个项目:

A: 00:00:00.2130628
B: 00:00:00.0574932

A现在慢得多.第一个示例的不同之处在于阵列分配确实导致了更多的CPU周期.

    AllocationAmount AllocationKind
B     1CAE0         Small
B     21E5C         Small
B     20020         Large
B     40020         Large
B     80020         Large
B    100020         Large
B    200020         Large
B    400020         Large
B    800020         Large
B   1000020         Large
A    B71B20         Large

这是垃圾收集器发出的GC AllocationTick ETW事件.实际上你确实比较了苹果和橙子.您的聚合调用基本上没有做任何事情.