Accepted answer

I just used the Reference Source to look into the code for Last and it checks to see if it is a IList<T> first and performs the appropriate O(1) call:

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();

So you have the slight overhead of a cast, but not the huge overhead of enumerating.


Short answer:



It's evident that Last() for List uses Count() extension method.

Count() checks type of the collection in runtime and uses Count property if it's available.

Count property for list has O(1) complexity so is the Last() extension method.


For List<T> it is O(1), but for other enumerables it may be O(N).


It contains an optimisation for anything that implements IList<T> in which case it just looks up the item at length -1.

Keep in mind that the vast majority of stuff you will send in will implement IList<T>


and so on ... all implement IList<T>

For those who can not look at the code to confirm, you can confirm it using observation:

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

            // warm up 

            var watch = Stopwatch.StartNew();
            for (int i = 0; i < iterations; i++) {
            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(); }); 




Raw performance Time Elapsed 1 ms
With Last Time Elapsed 31 ms

So it's only 30 times slower and maintains that performance profile with whatever length list you have, which is nothing in the big scheme of things.


You can just use Last with List<T> without worrying :)

Enumerable.Last attempts to downcast the IEnumerable<T> instance to IList<T> . If this is possible, it uses the indexer and Count property.

Here is part of the implementation as Reflector sees it:

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

Related Query

More Query from same tag