LINQ kullanarak bir sıradaki son eleman hariç tümünü nasıl alabilirim?

Diyelim ki bir sekansım var.

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

Sekans elde etmek ucuz değildir ve dinamik olarak üretilir ve bunu yalnızca bir kez yinelemek istiyorum.

0 - 999999 elde etmek istiyorum (yani son öğe hariç her şey)

Şunun gibi bir şey yapabileceğimin farkındayım:

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

ancak bu, büyük dizi üzerinde iki numaralandırma ile sonuçlanır.

Şunları yapmama izin veren bir LINQ yapısı var mı:

sequence.TakeAllButTheLastElement();

Bir Linq çözümü bilmiyorum - Ancak algoritmayı, jeneratörleri kullanarak kendi başınıza kolayca kodlayabilirsiniz (verim dö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()));
}

Veya son n öğeyi atan genel bir çözüm olarak (yorumlarda önerildiği gibi bir sıra kullanarak):

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

Kendi yönteminizi oluşturmanın bir alternatifi olarak ve bir durumda eleman sırasının önemli olmadığı durumda, bir sonraki işe yarayacaktır:

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

Açıkça bir kullanmanın hayranı olmadığım için Enumerator, işte bir alternatif. Sarmalayıcı yöntemlerinin, dizi gerçekten numaralandırılana kadar denetimleri ertelemek yerine geçersiz bağımsız değişkenlerin erken atılmasına izin vermek için gerekli olduğunu unutmayın.

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'in önerisine göre, kolayca n maddeye genelleştirilebilir:

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

Şimdi teslim ettikten sonra yerine teslim etmeden önce arabelleğe aldığım yerde , böylece n == 0vaka özel bir işleme gerek duymaz.

Enumerable.SkipLast(IEnumerable<TSource>, Int32)Yöntem, .NET Standard 2.1 ilave edildi. Tam olarak ne istiyorsan onu yapar.

IEnumerable<int> sequence = GetSequenceFromExpensiveSource();

var allExceptLast = sequence.SkipLast(1);

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

Kaynak koleksiyonun son sayı öğelerinin atlandığı kaynaktan öğeleri içeren yeni bir numaralandırılabilir koleksiyon döndürür.

BCL'de (veya inandığım MoreLinq'te) hiçbir şey yok, ancak kendi uzantı yönteminizi oluşturabilirsiniz.

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'ün bunun gibi bir uzatma yöntemiyle gönderilmesi faydalı olacaktır.

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

Joren'in zarif çözümünde küçük bir genişleme:

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

Shrink, ilk leftbirçok öğeyi bırakmak için ileri doğru basit bir sayım uyguladığında ve son rightbirçok öğeyi bırakmak için aynı atılan arabelleği kullanır .

kendi uzantınızı yayınlamaya vaktiniz yoksa, işte daha hızlı bir yol:

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

Kabul edilen yanıtta (zevklerime göre) biraz daha basit olan küçük bir değişiklik:

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

Eğer bir numaralandırılabilirden Countveya Lengthbirinden alabilirseniz , ki çoğu durumda bunu yapabilirsiniz, o zaman sadeceTake(n - 1)

Dizilerle örnek

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

Örnek IEnumerable<T>

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

Neden .ToList<type>()sırayla değil, sonra arama sayma ve başlangıçta yaptığınız gibi alın ... ama bir listeye alındığından, iki kez pahalı bir numaralandırma yapmamalı. Sağ?

Bu problem için kullandığım çözüm biraz daha karmaşık.

Kullanılan statik sınıfım -items içindeki -items'i MarkEnddönüştüren bir uzantı yöntemi içerir . Her öğe, 0 olan bir ekstra ile işaretlenir ; veya (son 3 maddeyle özellikle ilgilenilmesi durumunda) son 3 madde için -3 , -2 veya -1 .TEndMarkedItem<T>int

Bu, kendi başına yararlı olabilir, örneğinforeach , son 2 hariç her öğeden sonra virgül içeren basit bir döngüde, ikinciden son öğeye ve ardından bir bağlantılı sözcükle (" ve " gibi) bir liste oluşturmak istediğinizde veya " veya ") ve son öğe ve ardından bir nokta.

Son n öğe olmadan tüm listeyi oluşturmak için , uzantı yöntemi ButLastyalnızca EndMarkedItem<T>s while üzerinde yineler EndMark == 0.

Belirtmezseniz tailLength, yalnızca son öğe işaretlenir (içinde MarkEnd()) veya bırakılır (içinde ButLast()).

Diğer çözümler gibi, bu da arabelleğe alarak çalışır.

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

Bundan daha özlü olabileceğini düşünmüyorum - ayrıca aşağıdakileri ortadan kaldırmayı da garanti ediyor 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;
            }
        }
    }
}

Düzenleme: teknik olarak bu cevapla aynı .

C # 8.0 ile bunun için Aralıkları ve endeksleri kullanabilirsiniz .

var allButLast = sequence[..^1];

Varsayılan olarak C # 8.0, .NET Core 3.0 veya .NET Standard 2.1 (veya üzeri) gerektirir. Daha eski uygulamalarla kullanmak için bu diziyi kontrol edin .

Yazabilirsin:

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

Bu, tüm durumları doğru şekilde ele alacak genel ve IMHO zarif bir çözümdür:

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

Geleneksel IEnumerableyaklaşımım:

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

Basit bir yol, yalnızca bir kuyruğa dönüştürmek ve yalnızca atlamak istediğiniz öğe sayısı kalana kadar sırayı kaldırmaktır.

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

Olabilirdi:

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

Sanırım de "Nerede" gibi olmalı ama düzeni koruyarak (?).

Hız bir zorunluluksa, kod linq'in yapabileceği kadar pürüzsüz görünmese de, bu eski okul yolu en hızlı yol olmalıdır.

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

Bu, dizinin sabit bir uzunluğa ve dizinlenmiş öğelere sahip olması nedeniyle bir dizi olmasını gerektirir.

Muhtemelen şöyle bir şey yapardım:

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

Bu, her seferinde son olmadığını kontrol eden bir yinelemedir.