哪个更快:单个(谓词)或Where(谓词).单个()

Question

这个答案引起的讨论让我很好奇.哪个更快:

someEnumerable.Single(predicate);

要么

someEnumerable.Where(predicate).Single();

毕竟,第一个更短,更简洁,似乎是专门建造的.

甚至ReSharper建议前者:

我在上一篇文章中争论说,它们在功能上是相同的,并且应该具有非常相似的运行时.

Answer 1

LINQ到对象

没有什么像这样的基准回答像这样的问题:

(更新)

class Program
{
    const int N = 10000;
    volatile private static int s_val;

    static void DoTest(IEnumerable<int> data, int[] selectors) {
        Stopwatch s;

        // Using .Single(predicate)
        s = Stopwatch.StartNew();
        foreach (var t in selectors) {
            s_val = data.Single(x => x == t);
        }
        s.Stop();
        Console.WriteLine("   {0} calls to Single(predicate) took {1} ms.",
            selectors.Length, s.ElapsedMilliseconds);

        // Using .Where(predicate).Single()
        s = Stopwatch.StartNew();
        foreach (int t in selectors) {
            s_val = data.Where(x => x == t).Single();
        }
        s.Stop();
        Console.WriteLine("   {0} calls to Where(predicate).Single() took {1} ms.",
            selectors.Length, s.ElapsedMilliseconds);
    }


    public static void Main(string[] args) {
        var R = new Random();
        var selectors = Enumerable.Range(0, N).Select(_ => R.Next(0, N)).ToArray();

        Console.WriteLine("Using IEnumerable<int>  (Enumerable.Range())");
        DoTest(Enumerable.Range(0, 10 * N), selectors);

        Console.WriteLine("Using int[]");
        DoTest(Enumerable.Range(0, 10*N).ToArray(), selectors);

        Console.WriteLine("Using List<int>");
        DoTest(Enumerable.Range(0, 10 * N).ToList(), selectors);

        Console.ReadKey();
    }
}

有点令人震惊的是,.Where(predicate).Single()赢了大约两倍.我甚至两次运行两个案例以确保缓存等不是一个因素.

1) 10000 calls to Single(predicate) took 7938 ms.
1) 10000 calls to Where(predicate).Single() took 3795 ms.
2) 10000 calls to Single(predicate) took 8132 ms.
2) 10000 calls to Where(predicate).Single() took 4318 ms.

更新结果:

Using IEnumerable<int>  (Enumerable.Range())
   10000 calls to Single(predicate) took 7838 ms.
   10000 calls to Where(predicate).Single() took 8104 ms.
Using int[]
   10000 calls to Single(predicate) took 8859 ms.
   10000 calls to Where(predicate).Single() took 2970 ms.
Using List<int>
   10000 calls to Single(predicate) took 9523 ms.
   10000 calls to Where(predicate).Single() took 3781 ms.

Answer 2

Where(predicate).Single() 会比...更快 Single(predicate)

编辑:你会期望Single()和Single(predicate)以类似的方式编码,但事实并非如此.Single()一找到另一个元素就会完成,但后者会找到所有令人满意的元素.

感兴趣的(原来的答案)附加点- Where做特殊优化为不同类型的集合类型,而其他方法一样First,Single并Count没有考虑集合类型的优势.

所以Where(predicate).Single()能够做一些Single(predicate)没有的优化