Bir foreach boyunca geriye doğru yineleme mümkün mü?

Bir forifade kullanabileceğimi ve aynı etkiyi elde edebileceğimi biliyorum , ancak foreachC # 'da bir döngü boyunca geriye doğru döngü yapabilir miyim ?

Bir liste ile çalışırken (doğrudan indeksleme), bunu bir fordöngü kullanmak kadar verimli bir şekilde yapamazsınız .

Düzenle: ne zaman genel olarak anlamı muktedir bir kullanımı fordöngü, muhtemelen bu görev için doğru bir yöntem. Artı, foreachsırayla uygulandığı kadarıyla , yapının kendisi, paralel programlamada özellikle önemli olan öğe indekslerinden ve yineleme sırasından bağımsız döngüleri ifade etmek için oluşturulmuştur . Öyle Bence yineleme kullanmamalısınız sipariş güvenerek bu foreachdöngü için.

NET 3.5 üzerindeyseniz, bunu yapabilirsiniz:

IEnumerable<int> enumerableThing = ...;
foreach (var x in enumerableThing.Reverse())

Temelde numaralandırıcıdan her şeyi bir yığına koyarak ileriye gitmesi ve ardından her şeyi ters sırayla geri çıkarması gerektiği için çok verimli değildir.

Doğrudan indekslenebilir bir koleksiyonunuz varsa (örn. IList), forbunun yerine kesinlikle bir döngü kullanmalısınız.

.NET 2.0 üzerindeyseniz ve bir for döngüsü kullanamıyorsanız (yani, yalnızca bir IEnumerable'a sahipseniz), o zaman kendi Ters işlevinizi yazmanız gerekecektir. Bu çalışmalı:

static IEnumerable<T> Reverse<T>(IEnumerable<T> input)
{
    return new Stack<T>(input);
}

Bu, belki de o kadar açık olmayan bazı davranışlara dayanır. Bir IEnumerable'ı yığın yapıcısına ilettiğinizde, onu yineler ve öğeleri yığına iter. Daha sonra yığın üzerinde yinelediğinizde, her şeyi ters sırayla geri çıkarır.

Bu ve .NET 3.5 Reverse()genişletme yöntemi, öğeleri döndürmeyi asla bırakmayan bir IEnumerable ile beslerseniz açıkça patlayacaktır.

280Z28'in dediği gibi, bir için IList<T>sadece dizini kullanabilirsiniz. Bunu bir uzantı yönteminde gizleyebilirsiniz:

public static IEnumerable<T> FastReverse<T>(this IList<T> items)
{
    for (int i = items.Count-1; i >= 0; i--)
    {
        yield return items[i];
    }
}

Bu, Enumerable.Reverse()tüm verileri önce arabelleğe alandan daha hızlı olacaktır . (Bu Reverseşekilde uygulanan herhangi bir optimizasyon olduğuna inanmıyorum Count().) Bu arabelleğe alma işleminin, yinelemeye ilk başladığınızda verilerin tamamen okunduğu anlamına FastReversegelirken, siz yineleme sırasında listede yapılan değişiklikleri "göreceğiniz" anlamına gelir . (Yinelemeler arasında birden çok öğeyi kaldırırsanız da kırılır.)

Genel diziler için, ters yönde yinelemenin bir yolu yoktur - sıra sonsuz olabilir, örneğin:

public static IEnumerable<T> GetStringsOfIncreasingSize()
{
    string ret = "";
    while (true)
    {
        yield return ret;
        ret = ret + "x";
    }
}

Bunu tersine yinelemeye çalışsaydınız ne olmasını beklerdiniz?

foreachYineleme için kullanmadan önce listeyi şu reverseyöntemle ters çevirin :

    myList.Reverse();
    foreach( List listItem in myList)
    {
       Console.WriteLine(listItem);
    }

Bazen indeksleme lüksüne sahip değilsiniz ya da belki bir Linq sorgusunun sonuçlarını tersine çevirmek istiyorsunuz ya da belki kaynak koleksiyonunu değiştirmek istemiyorsunuz, bunlardan herhangi biri doğruysa, Linq size yardımcı olabilir.

Linq OrderByDescending için bir sıralama anahtarı sağlamak üzere Linq Select ile anonim türleri kullanan bir Linq genişletme yöntemi;

    public static IEnumerable<T> Invert<T>(this IEnumerable<T> source)
    {
        var transform = source.Select(
            (o, i) => new
            {
                Index = i,
                Object = o
            });

        return transform.OrderByDescending(o => o.Index)
                        .Select(o => o.Object);
    }

Kullanımı:

    var eable = new[]{ "a", "b", "c" };

    foreach(var o in eable.Invert())
    {
        Console.WriteLine(o);
    }

    // "c", "b", "a"

"Tersine Çevir" olarak adlandırılmıştır çünkü "Tersine Çevir" ile eşanlamlıdır ve Ters Liste uygulamasıyla belirsizliği gidermeyi etkinleştirir.

Bir koleksiyonun belirli aralıklarını tersine çevirmek de mümkündür, çünkü Int32.MinValue ve Int32.MaxValue herhangi bir koleksiyon indeksinin aralığının dışında olduğundan, sipariş süreci için bunları kullanabiliriz; bir öğe dizini verilen aralığın altındaysa, buna Int32.MaxValue atanır, böylece OrderByDescending kullanılırken sırası değişmez, benzer şekilde, verilen aralıktan daha büyük bir dizindeki öğelere Int32.MinValue atanır, böylece bunlar sipariş sürecinin sonunda görünür. Verilen aralıktaki tüm öğelere normal indeksleri atanır ve buna göre tersine çevrilir.

    public static IEnumerable<T> Invert<T>(this IEnumerable<T> source, int index, int count)
    {
        var transform = source.Select(
            (o, i) => new
            {
                Index = i < index ? Int32.MaxValue : i >= index + count ? Int32.MinValue : i,
                Object = o
            });

        return transform.OrderByDescending(o => o.Index)
                        .Select(o => o.Object);
    }

Kullanımı:

    var eable = new[]{ "a", "b", "c", "d" };

    foreach(var o in eable.Invert(1, 2))
    {
        Console.WriteLine(o);
    }

    // "a", "c", "b", "d"

Bir koleksiyonu tersine çevirmek için geçici bir Liste kullanmak yerine bu Linq uygulamalarının performans vuruşlarından emin değilim.

Yazarken, Linq'in kendi Reverse uygulamasından haberdar değildim, yine de bunu çalışmak eğlenceliydi. https://msdn.microsoft.com/en-us/library/vstudio/bb358497(v=vs.100).aspx

Liste <T> kullanıyorsanız, şu kodu da kullanabilirsiniz:

List<string> list = new List<string>();
list.Add("1");
list.Add("2");
list.Add("3");
list.Reverse();

Bu, listeyi kendi içinde tersine yazan bir yöntemdir.

Şimdi foreach:

foreach(string s in list)
{
    Console.WriteLine(s);
}

Çıktı:

3
2
1

Öyle Eğer toplama kodunu değiştirmek eğer mümkünse uygular IEnumerable veya IEnumerable (IList kendi uygulaması örneğin) o.

Bu işi sizin için yapan bir Yineleyici oluşturun , örneğin IEnumerable arabirimi aracılığıyla aşağıdaki uygulama gibi (bu örnekte ' öğeler'in bir Liste alanı olduğunu varsayarsak):

public IEnumerator<TObject> GetEnumerator()
{
    for (var i = items.Count - 1; i >= 0; i--)
    { 
        yield return items[i];
    }
}

IEnumerator IEnumerable.GetEnumerator()
{
    return GetEnumerator();
}

Bu nedenle Listeniz, listeniz boyunca ters sırada yinelenecektir.

Sadece bir ipucu: Listenizin bu özel davranışını dokümantasyon içinde açıkça belirtmelisiniz (Stack veya Queue gibi kendi kendini açıklayan bir sınıf adı seçerek daha da iyi).

Hayır. ForEach, her öğe için koleksiyon boyunca yineler ve sipariş, IEnumerable veya GetEnumerator () kullanıp kullanmadığına bağlıdır.

Jon Skeet'in güzel cevabını biraz detaylandırarak , bu çok yönlü olabilir:

public static IEnumerable<T> Directional<T>(this IList<T> items, bool Forwards) {
    if (Forwards) foreach (T item in items) yield return item;
    else for (int i = items.Count-1; 0<=i; i--) yield return items[i];
}

Ve sonra olarak kullan

foreach (var item in myList.Directional(forwardsCondition)) {
    .
    .
}

İşe yarayan bu kodu kullandım

                if (element.HasAttributes) {

                    foreach(var attr in element.Attributes().Reverse())
                    {

                        if (depth > 1)
                        {
                            elements_upper_hierarchy_text = "";
                            foreach (var ancest  in element.Ancestors().Reverse())
                            {
                                elements_upper_hierarchy_text += ancest.Name + "_";
                            }// foreach(var ancest  in element.Ancestors())

                        }//if (depth > 1)
                        xml_taglist_report += " " + depth  + " " + elements_upper_hierarchy_text+ element.Name + "_" + attr.Name +"(" + attr.Name +")" + "   =   " + attr.Value + "\r\n";
                    }// foreach(var attr in element.Attributes().Reverse())

                }// if (element.HasAttributes) {

Bu oldukça iyi çalışıyor

List<string> list = new List<string>();

list.Add("Hello");
list.Add("Who");
list.Add("Are");
list.Add("You");

foreach (String s in list)
{
    Console.WriteLine(list[list.Count - list.IndexOf(s) - 1]);
}