¿Llamar .Last() en un IList itera toda la lista?

Question

¿El método de extensión .Last() tiene en cuenta si se invoca en un IList? Me pregunto si hay una diferencia significativa entre el rendimiento siguientes:

IList<int> numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 

int lastNumber1 = numbers.Last(); 
int lastNumber2 = numbers[numbers.Count-1]; 

La intuición me dice que la primera alternativa es O (n), pero el segundo es O (1). ¿Es .Last() "inteligente" lo suficiente como para tratar de convertirlo a un IList?

Answer 1

Probablemente no

, ya que puede hacer list[list.count-1]

verificado por el reflector:

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]; 
     } 
    } 
    ... 
} 

Answer 2

reflector:

public static TSource Last<TSource>(this IEnumerable<TSource> source) 
{ 
    ... 
    if (list != null) 
    { 
     int count = list.Count; 
     if (count > 0) 
     { 
      return list[count - 1]; 
     } 
    } 
    else 
    { 
     using (IEnumerator<TSource> enumerator = source.GetEnumerator()) 
     { 
      ... 
     } 
    } 
    throw Error.NoElements(); 
} 

Answer 3

Respuesta: Sí.

Aquí está una manera ordenada para averiguar:

class MyList<T> : IList<T> { 
    private readonly List<T> list = new List<T>(); 
    public T this[int index] { 
     get { 
      Console.WriteLine("Inside indexer!"); 
      return list[index]; 
     } 
     set { 
      list[index] = value; 
     } 
    } 

    public void Add(T item) { 
     this.list.Add(item); 
    } 

    public int Count { 
     get { 
      Console.WriteLine("Inside Count!"); 
      return this.list.Count; 
     } 
    } 

    // all other IList<T> interface members throw NotImplementedException 
} 

continuación:

MyList<int> list = new MyList<int>(); 
list.Add(1); 
list.Add(2); 
Console.WriteLine(list.Last()); 

Salida:

Inside Count! 
Inside indexer! 
2 

Si intenta esto:

Console.WriteLine(list.Last(n => n % 2 == 0)); 

luego obtiene una excepción en GetEnumerator que muestra que está tratando de recorrer la lista. Si ponemos en práctica a través de GetEnumerator

public IEnumerator<T> GetEnumerator() { 
    Console.WriteLine("Inside GetEnumerator"); 
    return this.list.GetEnumerator(); 
} 

y tratar de nuevo vemos

Inside GetEnumerator! 
2 

en la consola que demuestra que nunca fue utilizado el indexador.

Answer 4

Se trata de una optimización indocumentada, pero la sobrecarga sin predicados de Enumerable.Last se omite directamente hasta el final.

Tenga en cuenta que la sobrecarga con un predicado no solo va desde el final, trabajando hacia atrás como cabría esperar, va hacia adelante desde el principio. Creo que esto es para evitar inconsistencias cuando el predicado puede lanzar una excepción (o causar otros efectos secundarios).

Consulte mi blog post about implementing First/Last/Single etc para obtener más información, y una incoherencia que es presente entre las sobrecargas de Single/SingleOrDefault.

Answer 5

El cartel original está hablando de una interfaz, no de la implementación.

Por lo tanto, depende de la implementación subyacente detrás del IList/Ilist<T> en cuestión. No se sabe cómo se implementa su indexador.Creo que el marco List<T> tiene una implementación concreta que utiliza una matriz, por lo que es posible realizar una búsqueda directa, pero si todo lo que tiene es una referencia a IList<T>, eso no es un hecho por ningún medio.