¿Cómo tomar todo menos el último elemento en una secuencia usando LINQ?

Digamos que tengo una secuencia.

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

Obtener la secuencia no es barata y se genera dinámicamente, y quiero repetirla solo una vez.

Quiero obtener 0 - 999999 (es decir, todo menos el último elemento)

Reconozco que podría hacer algo como:

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

pero eso da como resultado dos enumeraciones sobre la secuencia grande.

¿Hay una construcción LINQ que me permite hacer:

sequence.TakeAllButTheLastElement();

No conozco una solución de Linq, pero puede codificar fácilmente el algoritmo usted mismo utilizando generadores (rendimiento de rendimiento).

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

O como una solución generalizada descartando los últimos n elementos (usando una cola como se sugiere en los comentarios):

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 alternativa a la creación de su propio método y, en un caso, el orden de los elementos no es importante, el siguiente funcionará:

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

Como no soy fanático de usar explícitamente una Enumerator, aquí hay una alternativa. Tenga en cuenta que los métodos de envoltura son necesarios para permitir que los argumentos no válidos se lancen temprano, en lugar de diferir las comprobaciones hasta que la secuencia se enumere realmente.

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

Según la sugerencia de Eric Lippert, se generaliza fácilmente a n elementos:

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

Donde ahora amortiguo antes de ceder en lugar de después de ceder, para que el n == 0caso no necesite un manejo especial.

El Enumerable.SkipLast(IEnumerable<TSource>, Int32)método fue agregado en .NET Standard 2.1. Hace exactamente lo que quieres.

IEnumerable<int> sequence = GetSequenceFromExpensiveSource();

var allExceptLast = sequence.SkipLast(1);

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

Devuelve una nueva colección enumerable que contiene los elementos de origen con los últimos elementos de recuento de la colección de origen omitidos.

No hay nada en el BCL (o en MoreLinq, creo), pero podría crear su propio método de extensión.

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

Sería útil que .NET Framework se enviara con un método de extensión 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();
    }
}

Una ligera expansión en la elegante solución 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);
}

Donde shrink implementa un conteo simple hacia adelante para descartar los primeros leftelementos y el mismo búfer descartado para descartar los últimos rightelementos.

Si no tiene tiempo para implementar su propia extensión, esta es una forma más rápida:

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

Una ligera variación en la respuesta aceptada, que (para mis gustos) es un poco más simple:

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

Si puede obtener el Counto Lengthde un enumerable, que en la mayoría de los casos puede, entonces simplementeTake(n - 1)

Ejemplo con matrices

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

Ejemplo con IEnumerable<T>

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

¿Por qué no solo .ToList<type>()en la secuencia, luego llame y cuente como lo hizo originalmente ... pero como se ha incluido en una lista, no debería hacer una enumeración costosa dos veces? ¿Correcto?

La solución que uso para este problema es un poco más elaborada.

Mi clase estática util contiene un método de extensión MarkEndque convierte los T-items en EndMarkedItem<T>-items. Cada elemento está marcado con un extra int, que es 0 ; o (en caso de que uno esté particularmente interesado en los últimos 3 elementos) -3 , -2 o -1 para los últimos 3 elementos.

Esto podría ser útil por sí solo, por ejemplo , cuando desee crear una lista en un foreachbucle simple con comas después de cada elemento, excepto los 2 últimos, con el penúltimo elemento seguido de una palabra de conjunción (como " y " o " o "), y el último elemento seguido de un punto.

Para generar la lista completa sin los últimos n elementos, el método de extensión ButLastsimplemente itera sobre el EndMarkedItem<T>s while EndMark == 0.

Si no especifica tailLength, solo el último elemento se marca (en MarkEnd()) o se suelta (en ButLast()).

Al igual que las otras soluciones, esto funciona mediante almacenamiento en búfer.

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

No creo que pueda ser más sucinto que esto, y también me aseguro de desechar 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;
            }
        }
    }
}

Editar: técnicamente idéntico a esta respuesta .

Con C # 8.0 puede usar rangos e índices para eso.

var allButLast = sequence[..^1];

De manera predeterminada, C # 8.0 requiere .NET Core 3.0 o .NET Standard 2.1 (o superior). Verifique este hilo para usar con implementaciones anteriores.

Podrías escribir:

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

Esta es una solución elegante general y en mi humilde opinión que manejará todos los casos correctamente:

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

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

Una forma simple sería simplemente convertir a una cola y retirar hasta que solo quede la cantidad de elementos que desea omitir.

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

Podría ser:

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

Supongo que debería ser como "Dónde" pero preservando el orden (?).

Si la velocidad es un requisito, este método de la vieja escuela debería ser el más rápido, a pesar de que el código no se ve tan fluido como lo podría hacer linq.

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

Esto requiere que la secuencia sea una matriz, ya que tiene una longitud fija y elementos indexados.

Probablemente haría algo como esto:

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

Sin embargo, esta es una iteración con una verificación de que no es la última.