Bagaimana cara mengambil semua kecuali elemen terakhir secara berurutan menggunakan LINQ?

Katakanlah saya memiliki urutan.

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

Mendapatkan urutan tidak murah dan dihasilkan secara dinamis, dan saya ingin mengulanginya sekali saja.

Saya ingin mendapatkan 0 - 999999 (yaitu semuanya kecuali elemen terakhir)

Saya menyadari bahwa saya dapat melakukan sesuatu seperti:

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

tetapi itu menghasilkan dua enumerasi dalam urutan besar.

Apakah ada konstruksi LINQ yang memungkinkan saya melakukannya:

sequence.TakeAllButTheLastElement();

Saya tidak tahu solusi Linq - Tapi Anda dapat dengan mudah kode algoritma sendiri menggunakan generator (hasil pengembalian).

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

Atau sebagai solusi umum membuang n item terakhir (menggunakan antrian seperti yang disarankan dalam komentar):

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

Sebagai alternatif untuk membuat metode Anda sendiri dan dalam kasus urutan elemen tidak penting, selanjutnya akan berfungsi:

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

Karena saya bukan penggemar penggunaan eksplisit Enumerator, inilah alternatifnya. Perhatikan bahwa metode pembungkus diperlukan untuk membiarkan argumen yang tidak valid membuang lebih awal, daripada menunda pemeriksaan sampai urutan sebenarnya disebutkan.

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

Sesuai saran Eric Lippert, ini dengan mudah digeneralisasikan ke n item:

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

Di mana saya sekarang buffer sebelum menghasilkan bukan setelah menghasilkan, sehingga n == 0kasing tidak perlu penanganan khusus.

The Enumerable.SkipLast(IEnumerable<TSource>, Int32)Metode ditambahkan dalam NET Standard 2.1. Itu tepat seperti yang Anda inginkan.

IEnumerable<int> sequence = GetSequenceFromExpensiveSource();

var allExceptLast = sequence.SkipLast(1);

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

Mengembalikan koleksi enumerable baru yang berisi elemen dari sumber dengan elemen hitungan terakhir dari koleksi sumber dihilangkan.

Tidak ada dalam BCL (atau MoreLinq saya percaya), tetapi Anda dapat membuat metode ekstensi Anda sendiri.

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

Akan sangat membantu jika .NET Framework dikirimkan dengan metode ekstensi seperti ini.

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

Sedikit ekspansi pada solusi Joren yang elegan:

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

Di mana shrink mengimplementasikan penghitungan sederhana ke depan untuk menjatuhkan leftbanyak elemen pertama dan buffer buangan yang sama untuk menjatuhkan rightbanyak elemen terakhir .

jika Anda tidak punya waktu untuk meluncurkan ekstensi Anda sendiri, inilah cara yang lebih cepat:

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

Sedikit variasi pada jawaban yang diterima, yang (sesuai selera saya) sedikit lebih sederhana:

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

Jika Anda bisa mendapatkan Countatau Lengthmenghitung, yang dalam banyak kasus Anda bisa, maka adilTake(n - 1)

Contoh dengan array

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

Contoh dengan IEnumerable<T>

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

Mengapa tidak hanya .ToList<type>()pada urutan, lalu panggil hitungan dan ambil seperti yang Anda lakukan pada awalnya..tapi karena sudah ditarik ke dalam daftar, seharusnya tidak melakukan penghitungan mahal dua kali. Baik?

Solusi yang saya gunakan untuk masalah ini sedikit lebih rumit.

Kelas statis util saya berisi metode ekstensi MarkEndyang mengubah T-items di EndMarkedItem<T>-items. Setiap elemen ditandai dengan tambahan int, yaitu 0 ; atau (dalam kasus satu sangat tertarik pada 3 item terakhir) -3 , -2 , atau -1 untuk 3 item terakhir.

Ini bisa berguna sendiri, misalnya ketika Anda ingin membuat daftar di foreach-loop sederhana dengan koma setelah setiap elemen kecuali 2 terakhir, dengan item kedua-terakhir diikuti oleh kata penghubung (seperti " dan " atau " atau "), dan elemen terakhir diikuti oleh titik.

Untuk menghasilkan seluruh daftar tanpa n item terakhir , metode ekstensi ButLasthanya mengulang selama beberapa EndMarkedItem<T>saat EndMark == 0.

Jika Anda tidak menentukan tailLength, hanya item terakhir yang ditandai (masuk MarkEnd()) atau dijatuhkan (masuk ButLast()).

Seperti solusi lain, ini bekerja dengan buffering.

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

Saya tidak berpikir itu bisa menjadi lebih ringkas dari ini - juga memastikan untuk Buang 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;
            }
        }
    }
}

Sunting: secara teknis identik dengan jawaban ini .

Dengan C # 8.0 Anda dapat menggunakan Rentang dan indeks untuk itu.

var allButLast = sequence[..^1];

Secara default C # 8.0 memerlukan .NET Core 3.0 atau .NET Standard 2.1 (atau lebih tinggi). Periksa utas ini untuk digunakan dengan implementasi yang lebih lama.

Anda bisa menulis:

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

Ini adalah solusi umum dan IMHO elegan yang akan menangani semua kasus dengan benar:

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

IEnumerablePendekatan tradisional saya :

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

Cara sederhana adalah dengan hanya mengkonversi ke antrian dan dequeue sampai hanya jumlah item yang ingin Anda lewati yang tersisa.

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

Bisa jadi:

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

Saya kira itu harus seperti de "Di mana" tetapi menjaga urutan (?).

Jika kecepatan adalah persyaratan, cara jadul ini seharusnya menjadi yang tercepat, meskipun kodenya tidak semulus linq.

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

Ini mensyaratkan bahwa urutannya adalah array karena memiliki panjang yang tetap dan item yang diindeks.

Saya mungkin akan melakukan sesuatu seperti ini:

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

Ini adalah satu iterasi dengan cek bahwa itu bukan yang terakhir untuk setiap kali.