phương pháp khuyến nông LINQ để có yếu tố từ ngày kết thúc của chuỗi

Question

Có là phương pháp mở rộng đếm được

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

mà mất count yếu tố đầu tiên từ đầu.

Có cách nào để lấy các yếu tố từ cuối không? hoặc thậm chí tốt hơn một cách để đưa các yếu tố từ một bù đắp đến cùng?

Cảm ơn

Answer 1

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

hoặc

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

Có một số chi phí trong việc này do đó, một phương pháp tùy chỉnh sẽ tốt hơn.

Cập nhật: Một phương pháp tùy chỉnh

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

Cập nhật: Thay đổi mã một littlebit với ý tưởng từ dtb's trả lời :-)

Comment Bear: Nhìn này ví dụ:

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

Bạn có thể pote ntially thay đổi các giá trị của lastFive2 và do đó phương pháp tiếp cận đó có thể không an toàn hoặc ít nhất nó không phải là cách chức năng.

Để Bear:

Những gì tôi có nghĩa là về an toàn là thế này:

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? 

Trong những trường hợp này bạn sẽ phải tạo một bản sao để đảm bảo. Nhưng trong hầu hết trường hợp theo cách của bạn sẽ là tốt - và hiệu quả hơn một chút so với này để 1 :)

Một ý tưởng là sử dụng một hàng đợi mà chỉ có nội Enqueue, vv

Answer 2

MoreLINQ cung cấp một TakeLast extension method:

var last10 = finiteList.TakeLast(10); 

Chịu các yếu tố từ một bù đắp đến cùng, Enumerable.Skip nên làm các trick:

var allFromOffsetToEnd = finiteList.Skip(offset); 

Answer 3

Lưu ý về pe rformance. Rất nhiều câu trả lời ở đây hoạt động trên IEnumerable<> và đó có lẽ là những gì bạn cần và nên sử dụng.

Nhưng nếu tập hợp dữ liệu lớn và loại List<> hoặc tương tự, bạn có thể ngăn chặn rất nhiều iterating không cần thiết với một cái gì đó như:

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