Como pegar todos, exceto o último elemento em uma sequência usando o LINQ?

Digamos que eu tenho uma sequência.

IEnumerable<int> sequence = GetSequenceFromExpensiveSource();
// sequence now contains: 0,1,2,3,...,999999,1000000

Obter a sequência não é barato e é gerado dinamicamente, e quero iterá-la apenas uma vez.

Quero obter 0 - 999999 (ou seja, tudo, menos o último elemento)

Reconheço que eu poderia fazer algo como:

sequence.Take(sequence.Count() - 1);

mas isso resulta em duas enumerações na grande sequência.

Existe uma construção LINQ que me permite fazer:

sequence.TakeAllButTheLastElement();

Não conheço uma solução Linq - mas você pode codificar facilmente o algoritmo usando geradores (retorno de rendimento).

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

Ou como uma solução generalizada descartando os últimos n itens (usando uma fila como sugerido nos comentários):

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

Como uma alternativa para criar seu próprio método e, em um caso, a ordem dos elementos não for importante, o próximo funcionará:

var result = sequence.Reverse().Skip(1);

Porque eu não sou fã de usar explicitamente um Enumerator, aqui está uma alternativa. Observe que os métodos do wrapper são necessários para permitir que argumentos inválidos sejam lançados mais cedo, em vez de adiar as verificações até que a sequência seja realmente enumerada.

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

De acordo com a sugestão de Eric Lippert, generaliza facilmente n itens:

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

Onde agora eu buffer antes de render em vez de depois de render, para que o n == 0caso não precise de tratamento especial.

O Enumerable.SkipLast(IEnumerable<TSource>, Int32)método foi adicionado no .NET Standard 2.1. Faz exatamente o que você quer.

IEnumerable<int> sequence = GetSequenceFromExpensiveSource();

var allExceptLast = sequence.SkipLast(1);

De https://docs.microsoft.com/en-us/dotnet/api/system.linq.enumerable.skiplast

Retorna uma nova coleção enumerável que contém os elementos da origem com os últimos elementos de contagem omitidos.

Nada no BCL (ou MoreLinq eu acredito), mas você pode criar seu próprio método de extensão.

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

Seria útil se o .NET Framework fosse fornecido com um método de extensão como este.

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

Uma pequena expansão na solução elegante de Joren:

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

Onde o shrink implementa uma contagem simples para a frente para descartar os primeiros leftmuitos elementos e o mesmo buffer descartado para descartar os últimos rightmuitos elementos.

se você não tiver tempo para lançar sua própria extensão, eis uma maneira mais rápida:

var next = sequence.First();
sequence.Skip(1)
    .Select(s => 
    { 
        var selected = next;
        next = s;
        return selected;
    });

Uma pequena variação na resposta aceita, que (para o meu gosto) é um pouco mais simples:

    public static IEnumerable<T> AllButLast<T>(this IEnumerable<T> enumerable, int n = 1)
    {
        // for efficiency, handle degenerate n == 0 case separately 
        if (n == 0)
        {
            foreach (var item in enumerable)
                yield return item;
            yield break;
        }

        var queue = new Queue<T>(n);
        foreach (var item in enumerable)
        {
            if (queue.Count == n)
                yield return queue.Dequeue();

            queue.Enqueue(item);
        }
    }

Se você pode obter o Countou Lengthde um enumerável, o que, na maioria dos casos, é possível, bastaTake(n - 1)

Exemplo com matrizes

int[] arr = new int[] { 1, 2, 3, 4, 5 };
int[] sub = arr.Take(arr.Length - 1).ToArray();

Exemplo com IEnumerable<T>

IEnumerable<int> enu = Enumerable.Range(1, 100);
IEnumerable<int> sub = enu.Take(enu.Count() - 1);

Por que não apenas .ToList<type>()na sequência, então conte e atenda a chamada como você fez originalmente ... mas, como foi inserida em uma lista, ela não deve fazer uma enumeração cara duas vezes. Certo?

A solução que eu uso para esse problema é um pouco mais elaborada.

Minha classe estática util contém um método de extensão MarkEndque converte os Titens em EndMarkedItem<T>itens. Cada elemento é marcado com um extra int, que é 0 ; ou (caso um esteja particularmente interessado nos últimos 3 itens) -3 , -2 ou -1 nos últimos 3 itens.

Isso pode ser útil por si só, por exemplo , quando você deseja criar uma lista em um foreachloop simples com vírgulas após cada elemento, exceto os últimos 2, com o penúltimo item seguido por uma palavra conjunta (como " e " ou " ou ") e o último elemento seguido de um ponto.

Para gerar a lista inteira sem os últimos n itens, o método de extensão ButLastsimplesmente itera ao longo dos EndMarkedItem<T>segundos EndMark == 0.

Se você não especificar tailLength, apenas o último item será marcado (in MarkEnd()) ou descartado (in ButLast()).

Como as outras soluções, isso funciona em buffer.

using System;
using System.Collections.Generic;
using System.Linq;

namespace Adhemar.Util.Linq {

    public struct EndMarkedItem<T> {
        public T Item { get; private set; }
        public int EndMark { get; private set; }

        public EndMarkedItem(T item, int endMark) : this() {
            Item = item;
            EndMark = endMark;
        }
    }

    public static class TailEnumerables {

        public static IEnumerable<T> ButLast<T>(this IEnumerable<T> ts) {
            return ts.ButLast(1);
        }

        public static IEnumerable<T> ButLast<T>(this IEnumerable<T> ts, int tailLength) {
            return ts.MarkEnd(tailLength).TakeWhile(te => te.EndMark == 0).Select(te => te.Item);
        }

        public static IEnumerable<EndMarkedItem<T>> MarkEnd<T>(this IEnumerable<T> ts) {
            return ts.MarkEnd(1);
        }

        public static IEnumerable<EndMarkedItem<T>> MarkEnd<T>(this IEnumerable<T> ts, int tailLength) {
            if (tailLength < 0) {
                throw new ArgumentOutOfRangeException("tailLength");
            }
            else if (tailLength == 0) {
                foreach (var t in ts) {
                    yield return new EndMarkedItem<T>(t, 0);
                }
            }
            else {
                var buffer = new T[tailLength];
                var index = -buffer.Length;
                foreach (var t in ts) {
                    if (index < 0) {
                        buffer[buffer.Length + index] = t;
                        index++;
                    }
                    else {
                        yield return new EndMarkedItem<T>(buffer[index], 0);
                        buffer[index] = t;
                        index++;
                        if (index == buffer.Length) {
                            index = 0;
                        }
                    }
                }
                if (index >= 0) {
                    for (var i = index; i < buffer.Length; i++) {
                        yield return new EndMarkedItem<T>(buffer[i], i - buffer.Length - index);
                    }
                    for (var j = 0; j < index; j++) {
                        yield return new EndMarkedItem<T>(buffer[j], j - index);
                    }
                }
                else {
                    for (var k = 0; k < buffer.Length + index; k++) {
                        yield return new EndMarkedItem<T>(buffer[k], k - buffer.Length - index);
                    }
                }
            }    
        }
    }
}

    public static IEnumerable<T> NoLast<T> (this IEnumerable<T> items) {
        if (items != null) {
            var e = items.GetEnumerator();
            if (e.MoveNext ()) {
                T head = e.Current;
                while (e.MoveNext ()) {
                    yield return head; ;
                    head = e.Current;
                }
            }
        }
    }

Eu não acho que pode ser mais sucinto do que isso - também garantindo Dispose the IEnumerator<T>:

public static IEnumerable<T> SkipLast<T>(this IEnumerable<T> source)
{
    using (var it = source.GetEnumerator())
    {
        if (it.MoveNext())
        {
            var item = it.Current;
            while (it.MoveNext())
            {
                yield return item;
                item = it.Current;
            }
        }
    }
}

Edit: tecnicamente idêntico a esta resposta .

Com o C # 8.0, você pode usar intervalos e índices para isso.

var allButLast = sequence[..^1];

Por padrão, o C # 8.0 requer o .NET Core 3.0 ou o .NET Standard 2.1 (ou superior). Marque esta discussão para usar com implementações mais antigas.

Você pode escrever:

var list = xyz.Select(x=>x.Id).ToList();
list.RemoveAt(list.Count - 1);

Esta é uma solução geral e elegante do IMHO que manipulará todos os casos corretamente:

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        IEnumerable<int> r = Enumerable.Range(1, 20);
        foreach (int i in r.AllButLast(3))
            Console.WriteLine(i);

        Console.ReadKey();
    }
}

public static class LinqExt
{
    public static IEnumerable<T> AllButLast<T>(this IEnumerable<T> enumerable, int n = 1)
    {
        using (IEnumerator<T> enumerator = enumerable.GetEnumerator())
        {
            Queue<T> queue = new Queue<T>(n);

            for (int i = 0; i < n && enumerator.MoveNext(); i++)
                queue.Enqueue(enumerator.Current);

            while (enumerator.MoveNext())
            {
                queue.Enqueue(enumerator.Current);
                yield return queue.Dequeue();
            }
        }
    }
}

Minha IEnumerableabordagem tradicional :

/// <summary>
/// Skips first element of an IEnumerable
/// </summary>
/// <typeparam name="U">Enumerable type</typeparam>
/// <param name="models">The enumerable</param>
/// <returns>IEnumerable of type skipping first element</returns>
private IEnumerable<U> SkipFirstEnumerable<U>(IEnumerable<U> models)
{
    using (var e = models.GetEnumerator())
    {
        if (!e.MoveNext()) return;
        for (;e.MoveNext();) yield return e.Current;
        yield return e.Current;
    }
}

/// <summary>
/// Skips last element of an IEnumerable
/// </summary>
/// <typeparam name="U">Enumerable type</typeparam>
/// <param name="models">The enumerable</param>
/// <returns>IEnumerable of type skipping last element</returns>
private IEnumerable<U> SkipLastEnumerable<U>(IEnumerable<U> models)
{
    using (var e = models.GetEnumerator())
    {
        if (!e.MoveNext()) return;
        yield return e.Current;
        for (;e.MoveNext();) yield return e.Current;
    }
}

Uma maneira simples seria apenas converter para uma fila e desenfileirar até restar apenas o número de itens que você deseja pular.

public static IEnumerable<T> SkipLast<T>(this IEnumerable<T> source, int n)
{
    var queue = new Queue<T>(source);

    while (queue.Count() > n)
    {
        yield return queue.Dequeue();
    }
}

Poderia ser:

var allBuLast = sequence.TakeWhile(e => e != sequence.Last());

Eu acho que deveria ser como "Onde", mas preservando a ordem (?).

Se a velocidade é um requisito, essa maneira antiga deve ser a mais rápida, mesmo que o código não pareça tão suave quanto o linq poderia.

int[] newSequence = int[sequence.Length - 1];
for (int x = 0; x < sequence.Length - 1; x++)
{
    newSequence[x] = sequence[x];
}

Isso requer que a sequência seja uma matriz, pois possui um comprimento fixo e itens indexados.

Eu provavelmente faria algo assim:

sequence.Where(x => x != sequence.LastOrDefault())

Esta é uma iteração com uma verificação de que não é a última de cada vez.