Find（）与FirstOrDefault（）的性能

Question

  

类似问题：
  Find() vs. Where().FirstOrDefault()

在一个具有单个字符串属性的简单引用类型的大型序列中搜索Diana有一个有趣的结果。

using System;
using System.Collections.Generic;
using System.Linq;

public class Customer{
    public string Name {get;set;}
}

Stopwatch watch = new Stopwatch();        
    const string diana = "Diana";

    while (Console.ReadKey().Key != ConsoleKey.Escape)
    {
        //Armour with 1000k++ customers. Wow, should be a product with a great success! :)
        var customers = (from i in Enumerable.Range(0, 1000000)
                         select new Customer
                         {
                            Name = Guid.NewGuid().ToString()
                         }).ToList();

        customers.Insert(999000, new Customer { Name = diana }); // Putting Diana at the end :)

        //1. System.Linq.Enumerable.DefaultOrFirst()
        watch.Restart();
        customers.FirstOrDefault(c => c.Name == diana);
        watch.Stop();
        Console.WriteLine("Diana was found in {0} ms with System.Linq.Enumerable.FirstOrDefault().", watch.ElapsedMilliseconds);

        //2. System.Collections.Generic.List<T>.Find()
        watch.Restart();
        customers.Find(c => c.Name == diana);
        watch.Stop();
        Console.WriteLine("Diana was found in {0} ms with System.Collections.Generic.List<T>.Find().", watch.ElapsedMilliseconds);
    }

这是因为List.Find（）中没有Enumerator开销，还是加上其他东西？

Find()的运行速度几乎快了两倍，希望 .Net 团队不会将其标记为将来过时。

Answer 1

我能够模仿您的结果，因此我反编译了您的计划，Find和FirstOrDefault之间存在差异。

这里首先是反编译程序。我使您的数据对象成为仅用于编译的无数数据项

    List<\u003C\u003Ef__AnonymousType0<string>> source = Enumerable.ToList(Enumerable.Select(Enumerable.Range(0, 1000000), i =>
    {
      var local_0 = new
      {
        Name = Guid.NewGuid().ToString()
      };
      return local_0;
    }));
    source.Insert(999000, new
    {
      Name = diana
    });
    stopwatch.Restart();
    Enumerable.FirstOrDefault(source, c => c.Name == diana);
    stopwatch.Stop();
    Console.WriteLine("Diana was found in {0} ms with System.Linq.Enumerable.FirstOrDefault().", (object) stopwatch.ElapsedMilliseconds);
    stopwatch.Restart();
    source.Find(c => c.Name == diana);
    stopwatch.Stop();
    Console.WriteLine("Diana was found in {0} ms with System.Collections.Generic.List<T>.Find().", (object) stopwatch.ElapsedMilliseconds);

这里要注意的关键是在FirstOrDefault上调用Enumerable，而在源列表中调用Find作为方法。

那么，发现了什么？这是经过反编译的Find方法

private T[] _items;

[__DynamicallyInvokable]
public T Find(Predicate<T> match)
{
  if (match == null)
    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
  for (int index = 0; index < this._size; ++index)
  {
    if (match(this._items[index]))
      return this._items[index];
  }
  return default (T);
}

因此，它会迭代一个有意义的项目数组，因为列表是数组的包装器。

但是，FirstOrDefault上的Enumerable使用foreach来迭代这些项目。这将使用迭代器到列表并移动到下一个。我认为你看到的是迭代器的开销

[__DynamicallyInvokable]
public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
  if (source == null)
    throw Error.ArgumentNull("source");
  if (predicate == null)
    throw Error.ArgumentNull("predicate");
  foreach (TSource source1 in source)
  {
    if (predicate(source1))
      return source1;
  }
  return default (TSource);
}

使用可枚举模式的Foreach只是syntatic sugar。看看这张图片

。

我点击了foreach，看看它在做什么，你可以看到dotpeek想带我去调查器/当前/下一个有意义的实现。

除此之外，它们基本相同（测试传入的谓词以查看项目是否符合您的要求）

Answer 2

我通过FirstOrDefault实现下注IEnumerable正在运行，也就是说，它将使用标准foreach循环来进行检查。 List<T>.Find()不属于Linq（http://msdn.microsoft.com/en-us/library/x0b5b5bc.aspx），可能使用从for到0的标准Count循环（或者可能正在运行的其他快速内部机制）直接在其内部/包装数组上）。通过消除枚举的开销（并进行版本检查以确保列表未被修改），Find方法更快。

如果您添加第三个测试：

//3. System.Collections.Generic.List<T> foreach
Func<Customer, bool> dianaCheck = c => c.Name == diana;
watch.Restart();
foreach(var c in customers)
{
    if (dianaCheck(c))
        break;
}
watch.Stop();
Console.WriteLine("Diana was found in {0} ms with System.Collections.Generic.List<T> foreach.", watch.ElapsedMilliseconds);

速度与第一个相同（25ms vs FirstOrDefault 27ms

编辑：如果我添加一个数组循环，它会非常接近Find()速度，并且给出了@devshorts查看源代码，我认为就是这样：

//4. System.Collections.Generic.List<T> for loop
var customersArray = customers.ToArray();
watch.Restart();
int customersCount = customersArray.Length;
for (int i = 0; i < customersCount; i++)
{
    if (dianaCheck(customers[i]))
        break;
}
watch.Stop();
Console.WriteLine("Diana was found in {0} ms with an array for loop.", watch.ElapsedMilliseconds);

这比Find()方法慢了5.5％。

所以底线：循环遍历数组元素比处理foreach迭代开销更快。 （但两者都有它们的优点/缺点，所以只需从逻辑上选择对你的代码有意义的东西。此外，速度的小差异只会很少引起问题，所以只需使用对可维护性有意义的东西/可读性）