Wie nehme ich mit LINQ alle Elemente bis auf das letzte in einer Sequenz?

Nehmen wir an, ich habe eine Sequenz.

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

Das Abrufen der Sequenz ist nicht billig und wird dynamisch generiert, und ich möchte sie nur einmal durchlaufen.

Ich möchte 0 - 999999 erhalten (dh alles außer dem letzten Element)

Ich erkenne, dass ich so etwas tun könnte:

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

Dies führt jedoch zu zwei Aufzählungen über die große Sequenz.

Gibt es ein LINQ-Konstrukt, mit dem ich Folgendes tun kann:

sequence.TakeAllButTheLastElement();

Ich kenne keine Linq-Lösung - aber Sie können den Algorithmus einfach selbst mit Generatoren codieren (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()));
}

Oder als allgemeine Lösung, bei der die letzten n Elemente verworfen werden (unter Verwendung einer Warteschlange, wie in den Kommentaren vorgeschlagen):

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

Als Alternative zum Erstellen einer eigenen Methode und in einem Fall, in dem die Reihenfolge der Elemente nicht wichtig ist, funktioniert die nächste:

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

Da ich kein Fan von expliziter Verwendung von bin Enumerator, ist hier eine Alternative. Beachten Sie, dass die Wrapper-Methoden erforderlich sind, damit ungültige Argumente frühzeitig ausgelöst werden, anstatt die Überprüfungen zu verschieben, bis die Sequenz tatsächlich aufgelistet ist.

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

Gemäß dem Vorschlag von Eric Lippert lässt es sich leicht auf n Elemente verallgemeinern:

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

Wo ich jetzt vor dem Nachgeben statt nach dem Nachgeben puffere, so dass der n == 0Fall keine besondere Behandlung benötigt.

Die Enumerable.SkipLast(IEnumerable<TSource>, Int32)Methode wurde in .NET Standard 2.1 hinzugefügt. Es macht genau das, was Sie wollen.

IEnumerable<int> sequence = GetSequenceFromExpensiveSource();

var allExceptLast = sequence.SkipLast(1);

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

Gibt eine neue Aufzählungssammlung zurück, die die Elemente aus der Quelle enthält, wobei die letzten Zählelemente der Quellensammlung weggelassen wurden.

Nichts in der BCL (oder MoreLinq, glaube ich), aber Sie könnten Ihre eigene Erweiterungsmethode erstellen.

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

Es wäre hilfreich, wenn .NET Framework mit einer solchen Erweiterungsmethode ausgeliefert würde.

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

Eine leichte Erweiterung von Jorens eleganter Lösung:

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

Wobei Shrink eine einfache Vorwärtszählung implementiert, um die ersten leftvielen Elemente zu löschen, und denselben verworfenen Puffer, um die letzten rightvielen Elemente zu löschen .

Wenn Sie keine Zeit haben, Ihre eigene Erweiterung einzuführen, gehen Sie wie folgt vor:

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

Eine kleine Abweichung von der akzeptierten Antwort, die (für meinen Geschmack) etwas einfacher ist:

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

Wenn Sie das Countoder Lengtheines Aufzählers erhalten können, was Sie in den meisten Fällen können, dann einfachTake(n - 1)

Beispiel mit Arrays

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

Beispiel mit IEnumerable<T>

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

Warum nicht einfach .ToList<type>()in der Sequenz, dann zählen und nehmen, wie Sie es ursprünglich getan haben? Aber da es in eine Liste aufgenommen wurde, sollte es nicht zweimal eine teure Aufzählung durchführen. Richtig?

Die Lösung, die ich für dieses Problem verwende, ist etwas ausgefeilter.

Meine statische Klasse util enthält eine Erweiterungsmethode, MarkEnddie die T-items in EndMarkedItem<T>-items konvertiert. Jedes Element ist mit einem Extra gekennzeichnet int, das entweder 0 ist . oder (falls man sich besonders für die letzten 3 Elemente interessiert) -3 , -2 oder -1 für die letzten 3 Elemente.

Dies kann für sich genommen nützlich sein, z. B. wenn Sie eine Liste in einer einfachen foreachSchleife mit Kommas nach jedem Element mit Ausnahme der letzten 2 erstellen möchten , wobei auf das vorletzte Element ein Konjunktionswort folgt (z. B. " und "). oder " oder ") und das letzte Element, gefolgt von einem Punkt.

Um die gesamte Liste ohne die letzten n Elemente zu generieren , ButLastiteriert die Erweiterungsmethode einfach über das EndMarkedItem<T>s while EndMark == 0.

Wenn Sie nichts angeben tailLength, wird nur das letzte Element markiert (in MarkEnd()) oder gelöscht (in ButLast()).

Wie bei den anderen Lösungen funktioniert dies durch Puffern.

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

Ich denke nicht, dass es prägnanter werden kann - auch um sicherzustellen, dass 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;
            }
        }
    }
}

Bearbeiten: technisch identisch mit dieser Antwort .

Mit C # 8.0 können Sie dafür Bereiche und Indizes verwenden .

var allButLast = sequence[..^1];

Standardmäßig erfordert C # 8.0 .NET Core 3.0 oder .NET Standard 2.1 (oder höher). Überprüfen Sie diesen Thread für ältere Implementierungen.

Sie könnten schreiben:

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

Dies ist eine allgemeine und meiner Meinung nach elegante Lösung, die alle Fälle korrekt behandelt:

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

Mein traditioneller IEnumerableAnsatz:

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

Eine einfache Möglichkeit wäre, einfach in eine Warteschlange zu konvertieren und die Warteschlange zu verlassen, bis nur noch die Anzahl der Elemente übrig ist, die Sie überspringen möchten.

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

Könnte sein:

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

Ich denke, es sollte wie "Wo" sein, aber die Reihenfolge beibehalten (?).

Wenn Geschwindigkeit eine Voraussetzung ist, sollte dieser Weg der alten Schule der schnellste sein, auch wenn der Code nicht so flüssig aussieht, wie es linq machen könnte.

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

Dies erfordert, dass die Sequenz ein Array ist, da sie eine feste Länge und indizierte Elemente hat.

Ich würde wahrscheinlich so etwas machen:

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

Dies ist eine Iteration mit der Überprüfung, dass es nicht jedes Mal die letzte ist.