método de extensión linq para tomar elementos desde el extremo de la secuencia de

Question

Existe el método de extensión enumerable

Take<TSource>(
    IEnumerable<TSource> source, 
    int count 
) 

que toma los primeros count elementos desde el principio.

¿Hay alguna manera de tomar los elementos del final? o incluso mejor una forma de llevar los elementos de un desplazamiento al final?

Gracias

Answer 1

finiteList.Reverse().Take(count).Reverse(); 

o

finiteList.Skip(finiteList.Count() - count) 

Existe cierta sobrecarga en hacer esto por lo que un método personalizado sería mejor.

Actualización: Un método personalizado

public static class EnumerableExtensions 
{ 
    public static IEnumerable<T> TakeLast<T>(this IEnumerable<T> source, int count) 
    { 
     if (source == null) throw new ArgumentNullException("source"); 
     if (count < 0) throw new ArgumentOutOfRangeException("count"); 

     if (count == 0) yield break; 

     var queue = new Queue<T>(count); 

     foreach (var t in source) 
     { 
      if (queue.Count == count) queue.Dequeue(); 

      queue.Enqueue(t); 
     } 

     foreach (var t in queue) 
      yield return t; 
    } 
} 

Actualización: cambiado el código littlebit con las ideas de dtb's contestar :-)

comentario a Bear: Mira esto ejemplo:

var lastFive = Enumerable.Range(1, 10).TakeLast(5); 
var lastFive2 = Enumerable.Range(1, 10).TakeLast2(5); //Bear´s way 

Queue<int> q = (Queue<int>)lastFive2; 
q.Dequeue(); 

//Is lastFive2 still last five? no... 

Usted podría pote cambiar los valores de lastFive2 y, por lo tanto, ese enfoque puede ser inseguro o al menos no es la forma funcional.

de llevar

Lo que quería decir sobre el seguro es la siguiente:

var lastFive2 = Enumerable.Range(1, 10).TakeLast2(5); //Bear´s way 

//some = Some method which you don't control - it could be from another assembly which represents a crazy plugin etc. 
some(lastFive2); 
//Now what? 

En estos casos se tendría que hacer una copia para estar seguro. Pero en la mayoría de los casos, su forma sería muy bien - y un poco más eficiente que este modo :) 1

Una idea es utilizar una cola que sólo tiene interno Enqueue etc.

Answer 2

MoreLINQ proporciona una TakeLast extension method:

var last10 = finiteList.TakeLast(10); 

tomar los elementos partir de un desplazamiento hasta el final, Enumerable.Skip debe hacer el truco:

var allFromOffsetToEnd = finiteList.Skip(offset); 

Answer 3

una nota sobre la PE rendimiento Aquí encontrará muchas respuestas que operan en IEnumerable<> y eso es probablemente lo que necesita y debería usar.

Pero si los conjuntos de datos son grandes y de tipo List<> o similares, puede evitar una gran cantidad de iteración innecesaria con algo como:

// demo, no errorhandling 
public static IEnumerable<T> TakeFrom<T>(this IList<T> list, int offset) 
{ 
    for (int i = offset; i < list.Count; i += 1) 
    { 
     yield return list[i]; 
    } 
} 

Answer 4

@lasseespeholt:

public static class EnumerableExtensions 
{ 
    public static ReadOnlyEnumerable<T> AsReadOnly<T>(
     this IEnumerable<T> source) 
    { 
     return new ReadOnlyEnumerable<T>(source); 
    } 
} 

public sealed class ReadOnlyEnumerable<T> : IEnumerable<T> 
{ 
    private readonly IEnumerable<T> _source; 

    public ReadOnlyEnumerable(IEnumerable<T> source) 
    { 
     if (_source == null) 
     { 
      throw new ArgumentNullException("source"); 
     } 

     _source = source; 
    } 

    public IEnumerator<T> GetEnumerator() 
    { 
     return _source.GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return _source.GetEnumerator(); 
    } 
} 

public static IEnumerable<T> TakeLast<T>(this IEnumerable<T> source, int count) 
{ 
    if (source == null) throw new ArgumentNullException("source"); 
    if (count < 0) throw new ArgumentOutOfRangeException("count"); 

    if (count == 0) 
     return Enumerable.Empty<T>(); 

    var queue = new Queue<T>(count); 

    foreach (var t in source) 
    { 
     if (queue.Count == count) queue.Dequeue(); 

     queue.Enqueue(t); 
    } 

    return queue.AsReadOnly(); 
}