Используя Linq для получения последних элементов N набора?

Примечание : я пропустил заголовок вашего вопроса, в котором говорилось Использование Linq , поэтому в моем ответе Linq фактически не используется.

Если вы хотите избежать кеширования неленивой копии всей коллекции, вы можете написать простой метод, который делает это с помощью связанного списка.

Следующий метод добавит каждое значение, найденное в исходной коллекции, в связанный список и урежет связанный список до необходимого количества элементов. Поскольку он сохраняет связанный список обрезанным до этого количества элементов все время посредством итерации по коллекции, он будет хранить только копию не более N элементов из исходной коллекции.

Это не требует, чтобы вы знали количество элементов в исходной коллекции или повторяли его более одного раза.

Использование:

IEnumerable<int> sequence = Enumerable.Range(1, 10000);
IEnumerable<int> last10 = sequence.TakeLast(10);
...

Метод расширения:

public static class Extensions
{
    public static IEnumerable<T> TakeLast<T>(this IEnumerable<T> collection,
        int n)
    {
        if (collection == null)
            throw new ArgumentNullException("collection");
        if (n < 0)
            throw new ArgumentOutOfRangeException("n", "n must be 0 or greater");

        LinkedList<T> temp = new LinkedList<T>();

        foreach (var value in collection)
        {
            temp.AddLast(value);
            if (temp.Count > n)
                temp.RemoveFirst();
        }

        return temp;
    }
}

coll.Reverse().Take(N).Reverse().ToList();


public static IEnumerable<T> TakeLast<T>(this IEnumerable<T> coll, int N)
{
    return coll.Reverse().Take(N).Reverse();
}

ОБНОВЛЕНИЕ: для решения проблемы clintp: a) Использование метода TakeLast (), который я определил выше, решает проблему, но если вы действительно хотите сделать это без дополнительного метода, вам просто нужно поймите, что хотя Enumerable.Reverse () может использоваться как метод расширения, вам не обязательно использовать его таким образом:

List<string> mystring = new List<string>() { "one", "two", "three" }; 
mystring = Enumerable.Reverse(mystring).Take(2).Reverse().ToList();

Вот метод, который работает с любым перечислимым, но использует только временное хранилище O (N):

public static class TakeLastExtension
{
    public static IEnumerable<T> TakeLast<T>(this IEnumerable<T> source, int takeCount)
    {
        if (source == null) { throw new ArgumentNullException("source"); }
        if (takeCount < 0) { throw new ArgumentOutOfRangeException("takeCount", "must not be negative"); }
        if (takeCount == 0) { yield break; }

        T[] result = new T[takeCount];
        int i = 0;

        int sourceCount = 0;
        foreach (T element in source)
        {
            result[i] = element;
            i = (i + 1) % takeCount;
            sourceCount++;
        }

        if (sourceCount < takeCount)
        {
            takeCount = sourceCount;
            i = 0;
        }

        for (int j = 0; j < takeCount; ++j)
        {
            yield return result[(i + j) % takeCount];
        }
    }
}

Использование:

List<int> l = new List<int> {4, 6, 3, 6, 2, 5, 7};
List<int> lastElements = l.TakeLast(3).ToList();

Он работает с использованием кольцевого буфера размера N для хранения элементов в том виде, в каком он их видит, перезаписывая старые элементы с новыми. Когда достигается конец перечисляемого, кольцевой буфер содержит последние N элементов.

Если вы не против погрузиться в Rx как часть монады, вы можете использовать TakeLast :

IEnumerable<int> source = Enumerable.Range(1, 10000);

IEnumerable<int> lastThree = source.AsObservable().TakeLast(3).AsEnumerable();