.NET Core 2.0+提供了LINQ方法TakeLast():

https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.takelast

例子:

Enumerable
    .Range(1, 10)
    .TakeLast(3) // <--- takes last 3 items
    .ToList()
    .ForEach(i => System.Console.WriteLine(i))

// outputs:
// 8
// 9
// 10

如果你正在处理一个有键的集合(例如，来自数据库的条目)，一个快速(即比选择的答案更快)的解决方案将是

collection.OrderByDescending(c => c.Key).Take(3).OrderBy(c => c.Key);

我试图将效率和简单性结合起来，最后得到了这样的结果:

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

    Queue<T> lastElements = new Queue<T>();
    foreach (T element in source)
    {
        lastElements.Enqueue(element);
        if (lastElements.Count > count)
        {
            lastElements.Dequeue();
        }
    }

    return lastElements;
}

关于 在c#中，Queue<T>是使用循环缓冲区实现的，因此每次循环都没有对象实例化(只有当队列增长时)。我没有设置队列容量(使用专用构造函数)，因为有人可能使用count = int调用此扩展。MaxValue。为了获得额外的性能，您可以检查源实现IList是否<T>，如果是，则直接使用数组索引提取最后的值。

注意:我错过了你的问题标题说使用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(nameof(collection));
        if (n < 0)
            throw new ArgumentOutOfRangeException(nameof(n), $"{nameof(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;
    }
}

collection.Skip(Math.Max(0, collection.Count() - N));

这种方法保留了项目的顺序，不依赖于任何排序，并且在多个LINQ提供者之间具有广泛的兼容性。

重要的是要注意不要使用负数调用Skip。一些提供程序，比如实体框架，会在提供一个否定的参数时产生一个ArgumentException。对数学的呼唤。马克斯巧妙地避免了这一点。

下面的类具有扩展方法的所有基本要素，即:静态类、静态方法和this关键字的使用。

public static class MiscExtensions
{
    // Ex: collection.TakeLast(5);
    public static IEnumerable<T> TakeLast<T>(this IEnumerable<T> source, int N)
    {
        return source.Skip(Math.Max(0, source.Count() - N));
    }
}

关于性能的简要说明:

因为对Count()的调用可能导致某些数据结构的枚举，这种方法有导致两次数据传递的风险。对于大多数枚举对象来说，这并不是真正的问题;事实上，对于list、array甚至EF查询，已经有了优化，可以在O(1)时间内计算Count()操作。

但是，如果您必须使用只向前的枚举对象，并且希望避免进行两次传递，则可以考虑Lasse V. Karlsen或Mark Byers描述的一次传递算法。这两种方法都使用临时缓冲区来保存枚举时的项，一旦找到集合的末尾，就会产生这些项。

如果可以选择使用第三方库，则MoreLinq定义了TakeLast()。