Làm thế nào để lấy tất cả trừ phần tử cuối cùng trong chuỗi bằng LINQ?

Hãy nói rằng tôi có một chuỗi.

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

Bắt chuỗi không rẻ và được tạo động và tôi chỉ muốn lặp lại qua nó một lần.

Tôi muốn nhận 0 - 999999 (tức là mọi thứ trừ phần tử cuối cùng)

Tôi nhận ra rằng tôi có thể làm một cái gì đó như:

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

nhưng điều đó dẫn đến hai bảng liệt kê trong chuỗi lớn.

Có cấu trúc LINQ nào cho phép tôi làm không:

sequence.TakeAllButTheLastElement();

Tôi không biết một giải pháp Linq - Nhưng bạn có thể dễ dàng tự mình viết mã thuật toán bằng cách sử dụng các trình tạo (lợi nhuận).

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

Hoặc như một giải pháp tổng quát loại bỏ n mục cuối cùng (sử dụng hàng đợi như được đề xuất trong các nhận xét):

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

Thay thế cho việc tạo phương thức của riêng bạn và trong trường hợp thứ tự các phần tử không quan trọng, phần tiếp theo sẽ hoạt động:

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

Bởi vì tôi không phải là người thích sử dụng một cách rõ ràng Enumerator, đây là một sự thay thế. Lưu ý rằng các phương thức trình bao bọc là cần thiết để cho phép các đối số không hợp lệ xuất hiện sớm, thay vì trì hoãn việc kiểm tra cho đến khi chuỗi thực sự được liệt kê.

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

Theo đề xuất của Eric Lippert, nó dễ dàng khái quát hóa cho n mục:

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

Bây giờ tôi đệm trước khi cho năng suất thay vì sau khi cho năng suất, do đó n == 0trường hợp không cần xử lý đặc biệt.

Các Enumerable.SkipLast(IEnumerable<TSource>, Int32)phương pháp đã được bổ sung trong .NET chuẩn 2.1. Nó làm chính xác những gì bạn muốn.

IEnumerable<int> sequence = GetSequenceFromExpensiveSource();

var allExceptLast = sequence.SkipLast(1);

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

Trả về một bộ sưu tập vô số mới có chứa các phần tử từ nguồn với các phần tử đếm cuối cùng của bộ sưu tập nguồn bị bỏ qua.

Không có gì trong BCL (hoặc MoreLinq tôi tin), nhưng bạn có thể tạo phương thức mở rộng của riêng mình.

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

Sẽ rất hữu ích nếu .NET Framework được xuất xưởng với phương thức mở rộng như thế này.

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

Một sự mở rộng nhẹ về giải pháp tao nhã của 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);
}

Trong đó thu nhỏ thực hiện một số đếm đơn giản về phía trước để thả leftnhiều phần tử đầu tiên và bộ đệm bị loại bỏ tương tự để loại bỏ rightnhiều phần tử cuối cùng .

nếu bạn không có thời gian để triển khai tiện ích mở rộng của riêng mình, đây là cách nhanh hơn:

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

Một biến thể nhỏ trên câu trả lời được chấp nhận, mà (theo sở thích của tôi) thì đơn giản hơn một chút:

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

Nếu bạn có thể có được Counthoặc vô Lengthsố, trong hầu hết các trường hợp bạn có thể, thì chỉ cầnTake(n - 1)

Ví dụ với mảng

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

Ví dụ với IEnumerable<T>

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

Tại sao không chỉ .ToList<type>()trên chuỗi, sau đó gọi số đếm và thực hiện như bạn đã làm ban đầu..nhưng vì nó đã được kéo vào một danh sách, nó không nên thực hiện một phép liệt kê đắt tiền hai lần. Đúng?

Giải pháp mà tôi sử dụng cho vấn đề này phức tạp hơn một chút.

Lớp tĩnh của tôi chứa một phương thức mở rộng MarkEndgiúp chuyển đổi các T-items trong EndMarkedItem<T>-items. Mỗi phần tử được đánh dấu bằng một phần phụ int, là 0 ; hoặc (trong trường hợp một người đặc biệt quan tâm đến 3 mục cuối) -3 , -2 hoặc -1 cho 3 mục cuối.

Điều này có thể hữu ích về riêng của mình, ví dụ như khi bạn muốn tạo ra một danh sách một cách đơn giản foreach-loop bằng dấu phẩy sau mỗi yếu tố ngoại trừ người cuối cùng 2, với thứ hai-to-cuối cùng mục tiếp theo là một từ kết hợp (chẳng hạn như “ và ” hoặc hay hoặc ) và phần tử cuối cùng theo sau là một điểm.

Để tạo toàn bộ danh sách mà không có n mục cuối cùng , phương thức mở rộng ButLastchỉ đơn giản lặp lại trong EndMarkedItem<T>s EndMark == 0.

Nếu bạn không chỉ định tailLength, chỉ mục cuối cùng được đánh dấu (trong MarkEnd()) hoặc bỏ (trong ButLast()).

Giống như các giải pháp khác, điều này hoạt động bằng cách đệm.

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

Tôi không nghĩ rằng nó có thể trở nên cô đọng hơn thế này - cũng đảm bảo loại bỏ 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;
            }
        }
    }
}

Chỉnh sửa: kỹ thuật giống hệt với câu trả lời này .

Với C # 8.0, bạn có thể sử dụng Phạm vi và chỉ số cho điều đó.

var allButLast = sequence[..^1];

Theo mặc định, C # 8.0 yêu cầu .NET Core 3.0 hoặc .NET Standard 2.1 (hoặc cao hơn). Kiểm tra chủ đề này để sử dụng với các triển khai cũ hơn.

Bạn có thể viết:

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

Đây là một giải pháp thanh lịch chung và IMHO sẽ xử lý tất cả các trường hợp chính xác:

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

IEnumerableCách tiếp cận truyền thống của tôi :

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

Một cách đơn giản là chỉ cần chuyển đổi thành hàng đợi và dequeue cho đến khi chỉ còn lại số lượng mục bạn muốn bỏ qua.

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

Có thể là:

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

Tôi đoán nó nên giống như "Ở đâu" nhưng giữ trật tự (?).

Nếu tốc độ là một yêu cầu, cách học cũ này sẽ là nhanh nhất, mặc dù mã không có vẻ trơn tru như linq có thể làm được.

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

Điều này đòi hỏi chuỗi đó là một mảng vì nó có độ dài cố định và các mục được lập chỉ mục.

Tôi có thể sẽ làm một cái gì đó như thế này:

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

Đây là một lần lặp với một kiểm tra rằng nó không phải là lần cuối cùng cho mỗi lần.