假设我有一个序列。
IEnumerable<int> sequence = GetSequenceFromExpensiveSource();
// sequence now contains: 0,1,2,3,...,999999,1000000
获取这个序列是不廉价的，而且是动态生成的，我只想遍历一次。
我想要获取0-999999（即除最后一个元素外的所有元素）。
我知道我可以像这样做：
sequence.Take(sequence.Count() - 1);
但这会导致对大序列进行两次枚举。
是否有 LINQ 构造可让我执行：
sequence.TakeAllButTheLastElement();
Enumerable.SkipLast(IEnumerable<TSource>, Int32)方法在.NET Standard 2.1中添加。它正是你想要的。
IEnumerable<int> sequence = GetSequenceFromExpensiveSource();
var allExceptLast = sequence.SkipLast(1);
从https://learn.microsoft.com/zh-cn/dotnet/api/system.linq.enumerable.skiplast
返回一个新的可枚举集合，其中包含源中省略最后 count 个元素的元素。
我不知道Linq的解决方案 - 但是你可以使用生成器（yield return）轻松编写该算法。
public static IEnumerable<T> TakeAllButLast<T>(this IEnumerable<T> source) {
var it = source.GetEnumerator();
bool hasRemainingItems = false;
bool isFirst = true;
T item = default(T);
do {
hasRemainingItems = it.MoveNext();
if (hasRemainingItems) {
if (!isFirst) yield return item;
item = it.Current;
isFirst = false;
}
} while (hasRemainingItems);
}
static void Main(string[] args) {
var Seq = Enumerable.Range(1, 10);
Console.WriteLine(string.Join(", ", Seq.Select(x => x.ToString()).ToArray()));
Console.WriteLine(string.Join(", ", Seq.TakeAllButLast().Select(x => x.ToString()).ToArray()));
}
public static IEnumerable<T> SkipLastN<T>(this IEnumerable<T> source, int n) {
var it = source.GetEnumerator();
bool hasRemainingItems = false;
var cache = new Queue<T>(n + 1);
do {
if (hasRemainingItems = it.MoveNext()) {
cache.Enqueue(it.Current);
if (cache.Count > n)
yield return cache.Dequeue();
}
} while (hasRemainingItems);
}
static void Main(string[] args) {
var Seq = Enumerable.Range(1, 4);
Console.WriteLine(string.Join(", ", Seq.Select(x => x.ToString()).ToArray()));
Console.WriteLine(string.Join(", ", Seq.SkipLastN(3).Select(x => x.ToString()).ToArray()));
}
如果您不想创建自己的方法，且元素的顺序不重要，可以使用以下方法：
var result = sequence.Reverse().Skip(1);
equence.Reverse().Skip(1).Reverse() 不是一个好的解决方案。 - shashwatEnumerator，所以这里提供一种替代方案。请注意，需要包装器方法来让无效参数尽早抛出异常，而不是在实际枚举序列之前延迟检查。public static IEnumerable<T> DropLast<T>(this IEnumerable<T> source)
{
if (source == null)
throw new ArgumentNullException("source");
return InternalDropLast(source);
}
private static IEnumerable<T> InternalDropLast<T>(IEnumerable<T> source)
{
T buffer = default(T);
bool buffered = false;
foreach (T x in source)
{
if (buffered)
yield return buffer;
buffer = x;
buffered = true;
}
}
根据Eric Lippert的建议，它可以轻松地扩展到n个项目：
public static IEnumerable<T> DropLast<T>(this IEnumerable<T> source, int n)
{
if (source == null)
throw new ArgumentNullException("source");
if (n < 0)
throw new ArgumentOutOfRangeException("n",
"Argument n should be non-negative.");
return InternalDropLast(source, n);
}
private static IEnumerable<T> InternalDropLast<T>(IEnumerable<T> source, int n)
{
Queue<T> buffer = new Queue<T>(n + 1);
foreach (T x in source)
{
buffer.Enqueue(x);
if (buffer.Count == n + 1)
yield return buffer.Dequeue();
}
}
我现在在yield之前进行缓冲，而不是之后，这样就不需要对n == 0的情况进行特殊处理了。
DropLast时获得验证。否则，验证将仅在实际枚举序列时发生（在生成的 IEnumerator 上的第一次调用 MoveNext）。当在生成 IEnumerable 和实际枚举它之间可能存在任意数量的代码时，这不是一个有趣的调试事情。现在我会将InternalDropLast编写为DropLast的内部函数，但当我9年前编写这段代码时，这个功能在C#中并不存在。 - Joren在BCL（或者我相信是MoreLinq）中没有这个功能，但是你可以创建自己的扩展方法。
public static IEnumerable<T> TakeAllButLast<T>(this IEnumerable<T> source)
{
using (var enumerator = source.GetEnumerator())
bool first = true;
T prev;
while(enumerator.MoveNext())
{
if (!first)
yield return prev;
first = false;
prev = enumerator.Current;
}
}
}
if (!first) 并将 first = false 移出 if 语句块。 - Calebprev，之后无限循环”。 - Phil Millerusing 语句。 - Noldorinpublic static IEnumerable<T> SkipLast<T>(this IEnumerable<T> source, int count)
{
var enumerator = source.GetEnumerator();
var queue = new Queue<T>(count + 1);
while (true)
{
if (!enumerator.MoveNext())
break;
queue.Enqueue(enumerator.Current);
if (queue.Count > count)
yield return queue.Dequeue();
}
}
var next = sequence.First();
sequence.Skip(1)
.Select(s =>
{
var selected = next;
next = s;
return selected;
});
public static IEnumerable<T> Shrink<T>(this IEnumerable<T> source, int left, int right)
{
int i = 0;
var buffer = new Queue<T>(right + 1);
foreach (T x in source)
{
if (i >= left) // Read past left many elements at the start
{
buffer.Enqueue(x);
if (buffer.Count > right) // Build a buffer to drop right many elements at the end
yield return buffer.Dequeue();
}
else i++;
}
}
public static IEnumerable<T> WithoutLast<T>(this IEnumerable<T> source, int n = 1)
{
return source.Shrink(0, n);
}
public static IEnumerable<T> WithoutFirst<T>(this IEnumerable<T> source, int n = 1)
{
return source.Shrink(n, 0);
}
当缩小实现简单地向前计数以删除前面的left个元素，并使用相同的丢弃缓冲区来删除后面的right个元素。
Count或Length，在大多数情况下都可以这样做，只需使用Take(n - 1)即可。
数组示例
int[] arr = new int[] { 1, 2, 3, 4, 5 };
int[] sub = arr.Take(arr.Length - 1).ToArray();
使用 IEnumerable<T> 的示例
IEnumerable<int> enu = Enumerable.Range(1, 100);
IEnumerable<int> sub = enu.Take(enu.Count() - 1);
sequenceList.RemoveAt(sequence.Count - 1);来进行缓存。在我的情况下，这是可以接受的，因为在所有LINQ操作之后，我必须将其转换为数组或IReadOnlyCollection。我想知道你的使用情况，在那里你甚至不考虑缓存？正如我所看到的，即使是批准的答案也会进行一些缓存，因此在我看来，简单地转换为List更容易和更短。 - Pavels Ahmadulins