LINQを使用してシーケンスの最後の要素を除くすべてを取得する方法は？

シーケンスがあるとしましょう。

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

シーケンスを取得するのは安くなく、動的に生成されるので、1回だけ繰り返し処理したい

0-999999（つまり、最後の要素以外のすべて）を取得したい

私は次のようなことができることを認識しています：

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

しかし、その結果、大きなシーケンスに対して2つの列挙が生じます。

私ができるLINQ構造はありますか：

sequence.TakeAllButTheLastElement();

Linqソリューションはわかりません-しかし、ジェネレーターを使用して自分でアルゴリズムを簡単にコーディングできます（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()));
}

または、最後のnアイテムを破棄する一般化されたソリューションとして（コメントで提案されているようなキューを使用）：

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

独自のメソッドを作成する代わりに、要素の順序が重要でない場合は、次の方法が機能します。

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

私は明示的にを使用するのが好きではないためEnumerator、代わりの方法を次に示します。ラッパーメソッドは、シーケンスが実際に列挙されるまでチェックを延期するのではなく、無効な引数を早期にスローさせるために必要です。

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

Eric Lippertの提案に従って、n個の項目に簡単に一般化します。

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

降格後ではなく降格前にバッファリングするため、n == 0特別な処理は必要ありません。

このEnumerable.SkipLast(IEnumerable<TSource>, Int32)メソッドは.NET Standard 2.1で追加されました。それはまさにあなたが望むものを行います。

IEnumerable<int> sequence = GetSequenceFromExpensiveSource();

var allExceptLast = sequence.SkipLast(1);

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

ソースコレクションの最後のcount個の要素が省略された、ソースの要素を含む新しい列挙可能なコレクションを返します。

BCL（または私が信じているMoreLinq）には何もありませんが、独自の拡張メソッドを作成できます。

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

.NET Frameworkにこのような拡張メソッドが同梱されていると便利です。

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

ヨレンのエレガントなソリューションのわずかな拡張：

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

シュリンクは、最初のleft多くの要素を削除するための単純なカウントフォワードと、最後のright多くの要素を削除するための同じ破棄バッファーを実装します。

独自の拡張機能を展開する時間がない場合は、次の方法で簡単にできます。

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

受け入れられた回答のわずかなバリエーション。これは（私の好みでは）少し簡単です。

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

Countor Lengthを取得できる場合は、ほとんどの場合はそれを取得できます。Take(n - 1)

配列の例

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

の例 IEnumerable<T>

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

なぜ.ToList<type>()シーケンスだけでなく、最初に行ったようにcountおよびtakeを呼び出します。正しい？

この問題に使用する解決策はもう少し複雑です。

私のutil静的クラスにはMarkEnd、T-itemsの-items を変換する拡張メソッドが含まれていEndMarkedItem<T>ます。各要素にはint、0である追加のマークが付けられます。または（最後の3アイテムに特に関心がある場合）-3、-2、または-1、最後の3アイテム。

これは、それ自体が役立つ場合があります。たとえばforeach、最後の2を除く各要素の後にカンマを付けた単純なループでリストを作成する場合、最後から2番目の項目の後に結合語が続く（「および」など）または「または」）、およびポイントが続く最後の要素。

最後のnアイテムなしでリスト全体を生成するために、拡張メソッドButLastはEndMarkedItem<T>sを単純に繰り返しながらEndMark == 0ます。

を指定しない場合tailLength、最後のアイテムのみがマーク（MarkEnd()または）またはドロップ（ButLast()）されます。

他のソリューションと同様に、これはバッファリングによって機能します。

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

私はそれがこれより簡潔になるとは思わない-また、Disposeを確実にする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;
            }
        }
    }
}

編集：この回答と技術的に同一です。

C＃8.0では、そのために範囲とインデックスを使用できます。

var allButLast = sequence[..^1];

デフォルトでは、C＃8.0には.NET Core 3.0または.NET Standard 2.1（またはそれ以上）が必要です。このスレッドをチェックして、古い実装で使用してください。

あなたは書くことができます：

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

これは、すべてのケースを正しく処理する一般的でIMHOのエレガントなソリューションです。

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

私の伝統的なIEnumerableアプローチ：

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

簡単な方法は、キューに変換して、スキップするアイテムの数だけが残るまでデキューすることです。

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

になり得る：

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

de "Where"のように見えるはずですが、順序を保持しています（？）

速度が要件である場合、コードがlinqで実現できるほど滑らかではない場合でも、この古い方法が最も高速です。

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

シーケンスには固定長とインデックス付きのアイテムがあるため、シーケンスは配列である必要があります。

私はおそらくこのようなことをするでしょう：

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

これは、毎回最後ではないことを確認する1回の反復です。