linq méthode d'extension pour prendre des éléments à partir de la fin de la séquence

Question

Il y a la méthode d'extension dénombrable

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

qui prend les premiers éléments count dès le début.

Y at-il un moyen de prendre les éléments de la fin? ou même mieux un moyen de prendre les éléments d'un décalage à la fin?

Merci

Answer 1

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

ou

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

Il y a certains frais généraux, ce faisant, si une méthode personnalisée serait mieux.

Mise à jour: Une méthode personnalisée

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

Mise à jour: modifié le code d'un littlebit avec des idées de dtb's répondre :-)

Commentaire Bear: Regardez ce exemple:

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... 

Vous pourriez pote changer les valeurs de lastFive2 et donc cette approche peut être dangereuse ou du moins ce n'est pas la manière fonctionnelle.

à BEAR:

Ce que je voulais dire au sujet de la sécurité est la suivante:

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? 

Dans ces cas, vous auriez à faire une copie pour être sûr. Mais dans la plupart des cas, votre façon serait bien - et un peu plus efficace que cela pour +1 :)

Une idée est d'utiliser une file d'attente qui n'ont Enqueue interne, etc.

Answer 2

MoreLINQ fournit un TakeLast extension method:

var last10 = finiteList.TakeLast(10); 

pour prendre les éléments d'un décalage à la fin, Enumerable.Skip devrait faire l'affaire:

var allFromOffsetToEnd = finiteList.Skip(offset); 

Answer 3

une note sur pe performance. Beaucoup de réponses opèrent sur IEnumerable<> et c'est probablement ce dont vous avez besoin et que vous devriez utiliser.

Mais si les ensembles de données sont grandes et de type List<> ou similaire, vous pouvez éviter beaucoup de itérer inutiles avec quelque chose comme:

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