List<T> 的 Last() 扩展方法的性能如何？

Question

我真的很喜欢Last()，并且会一直使用它来处理List<T>s。但由于它似乎是为IEnumerable<T> 定义的，我猜它首先枚举了枚举——这应该是 O(n) 而不是 O(1) 用于直接索引 List<T> 的最后一个元素。

标准 (Linq) 扩展方法是否意识到这一点？

C++ 中的 STL 通过迭代器等的完整“继承树”意识到这一点。

Answer 1

我刚刚使用 Reference Source 查看 Last 的代码，它首先检查它是否是 IList<T> 并执行适当的 O(1) 调用：

public static TSource Last < TSource > (this IEnumerable < TSource > source) {
    if (source == null) throw Error.ArgumentNull("source");
    IList < TSource > list = source as IList < TSource > ;
    if (list != null) {
        int count = list.Count;
        if (count > 0) return list[count - 1];
    }
    else {
        using(IEnumerator < TSource > e = source.GetEnumerator()) {
            if (e.MoveNext()) {
                TSource result;
                do {
                    result = e.Current;
                } while ( e . MoveNext ());
                return result;
            }
        }
    }
    throw Error.NoElements();
}

---

所以你有一个演员的轻微开销，但没有枚举的巨大开销。

Answer 2

您可以将 Last 与 List<T> 一起使用而无需担心 :)

Enumerable.Last 尝试将 IEnumerable<T> 实例向下转换为 IList<T> 。如果可能，它会使用 indexer 和 Count 属性。

这是Reflector 看到的部分实现：

IList<TSource> list = source as IList<TSource>;
if (list != null)
{
    int count = list.Count;
    if (count > 0)
    {
        return list[count - 1];
    }
}

Answer 3

它包含对任何实现IList<T> 的优化，在这种情况下它只是查找长度为-1 的项目。

请记住，您发送的绝大多数内容都将实现IList<T>

List<int> 
int[] 

等等……都实现IList<T>

不能看代码确认的可以通过观察来确认：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace ConsoleApplication4 {
    class Program {

        static void Profile(string description, int iterations, Action func) {

            // clean up
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();

            // warm up 
            func();

            var watch = Stopwatch.StartNew();
            for (int i = 0; i < iterations; i++) {
                func();
            }
            watch.Stop();
            Console.Write(description);
            Console.WriteLine(" Time Elapsed {0} ms", watch.ElapsedMilliseconds);
        }

        static void Main(string[] args) {
            int[] nums = Enumerable.Range(1, 1000000).ToArray();

            int a;

            Profile("Raw performance", 100000, () => { a = nums[nums.Length - 1];  });
            Profile("With Last", 100000, () => { a = nums.Last(); }); 

            Console.ReadKey();
        }


    }
}

输出：

原始性能经过时间 1 毫秒 上次经过 31 毫秒

所以它只慢了 30 倍，并且无论您拥有什么长度的列表，它都能保持该性能配置文件，这在大计划中算不了什么。

Answer 4

对于List<T>，它是 O(1)，但对于其他可枚举，它可能是 O(N)。

Answer 5

简答：

O(1).

说明：

很明显 Last() for List 使用了 Count() 扩展方法。

Count() 在运行时检查集合的类型，如果可用则使用 Count 属性。

列表的

Count 属性具有 O(1) 复杂度，Last() 扩展方法也是如此。