方案一

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

我们也可以把它写成一个静态扩展方法，如：

public static class MiscExtensions

{

    public static IEnumerable<T> TakeLast<T>(this IEnumerable<T> source, int N)

    {

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

    }

}

调用方法：

collection.TakeLast(5);

方案二

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

静态扩展类如：

public static IEnumerable<T> TakeLast<T>(this IEnumerable<T> coll, int N)

{

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

}

调用方法：

coll.TakeLast(5);

如果不想使用静态扩展方法，还可以使用 Enumerable.Reverse() 方法，如下：

List<string> mystring = new List<string>() { "one", "two", "three" };

mystring = Enumerable.Reverse(mystring).Take(2).Reverse().ToList();

方案三

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;

    }

}

调用方法：

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

IEnumerable<int> last10 = sequence.TakeLast(10);

方案四

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

方案五

public static IEnumerable<T> FilterLastN<T>(this IEnumerable<T> source, int n, Predicate<T> pred)

{

    int goldenIndex = source.Count() - n;

    return source.SkipWhile((val, index) => index < goldenIndex && pred(val));

}

方案六

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

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