Möglich, durch einen Foreach rückwärts zu iterieren?

Ich weiß, dass ich eine forAnweisung verwenden und den gleichen Effekt erzielen kann, aber kann ich eine foreachSchleife in C # rückwärts durchlaufen ?

Wenn Sie mit einer Liste arbeiten (direkte Indizierung), können Sie dies nicht so effizient tun wie mit einer forSchleife.

Edit: Was bedeutet in der Regel, wenn Sie sind die Lage , einen verwenden , forSchleife, ist es wahrscheinlich die richtige Methode für diese Aufgabe. Darüber hinaus foreachist das Konstrukt selbst so weit wie in der Reihenfolge implementiert implementiert, um Schleifen auszudrücken, die unabhängig von Elementindizes und Iterationsreihenfolge sind, was bei der parallelen Programmierung besonders wichtig ist . Es ist meiner Meinung nach, dass Iteration auf Bestellung verlassen sollte nicht verwendet werden foreachfür Looping.

Wenn Sie mit .NET 3.5 arbeiten, können Sie Folgendes tun:

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

Es ist nicht sehr effizient, da es im Grunde genommen den Enumerator durchlaufen muss, um alles auf einen Stapel zu legen, und dann alles in umgekehrter Reihenfolge wieder herausspringt.

Wenn Sie eine direkt indizierbare Sammlung haben (z. B. IList), sollten Sie forstattdessen auf jeden Fall eine Schleife verwenden.

Wenn Sie sich in .NET 2.0 befinden und keine for-Schleife verwenden können (dh Sie haben nur eine IEnumerable), müssen Sie nur Ihre eigene Umkehrfunktion schreiben. Das sollte funktionieren:

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

Dies beruht auf einem Verhalten, das vielleicht nicht so offensichtlich ist. Wenn Sie eine IEnumerable an den Stapelkonstruktor übergeben, durchläuft sie diese und schiebt die Elemente auf den Stapel. Wenn Sie dann durch den Stapel iterieren, werden die Dinge in umgekehrter Reihenfolge wieder herausgeschleudert.

Diese und die .NET 3.5- Reverse()Erweiterungsmethode werden offensichtlich in die Luft gesprengt, wenn Sie eine IEnumerable eingeben, die niemals aufhört, Elemente zurückzugeben.

Wie 280Z28 sagt, können Sie für einen IList<T>einfach den Index verwenden. Sie können dies in einer Erweiterungsmethode ausblenden:

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

Dies ist schneller, als wenn Enumerable.Reverse()zuerst alle Daten gepuffert werden. (Ich glaube nicht, Reversedass Optimierungen auf diese Weise angewendet wurden Count().) Beachten Sie, dass diese Pufferung bedeutet, dass die Daten beim ersten Start der Iteration vollständig gelesen werden, während FastReversealle Änderungen, die während der Iteration an der Liste vorgenommen wurden, "angezeigt" werden. (Es wird auch unterbrochen, wenn Sie mehrere Elemente zwischen den Iterationen entfernen.)

Bei allgemeinen Sequenzen gibt es keine Möglichkeit, umgekehrt zu iterieren - die Sequenz kann unendlich sein, zum Beispiel:

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

Was würden Sie erwarten, wenn Sie versuchen würden, dies in umgekehrter Reihenfolge zu wiederholen?

foreachKehren Sie die Liste vor der Verwendung für die Iteration wie folgt um reverse:

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

Manchmal haben Sie nicht den Luxus der Indizierung, oder Sie möchten die Ergebnisse einer Linq-Abfrage umkehren oder die Quellensammlung nicht ändern. Wenn eine dieser Angaben zutrifft, kann Linq Ihnen helfen.

Eine Linq-Erweiterungsmethode, die anonyme Typen mit Linq Select verwendet, um einen Sortierschlüssel für Linq OrderByDescending bereitzustellen.

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

Verwendung:

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

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

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

Es heißt "Invertieren", weil es gleichbedeutend mit "Reverse" ist und die Disambiguierung mit der List Reverse-Implementierung ermöglicht.

Es ist auch möglich, bestimmte Bereiche einer Sammlung umzukehren, da Int32.MinValue und Int32.MaxValue außerhalb des Bereichs jeder Art von Sammlungsindex liegen. Wir können sie für den Bestellvorgang nutzen. Wenn ein Elementindex unter dem angegebenen Bereich liegt, wird ihm Int32.MaxValue zugewiesen, damit sich seine Reihenfolge bei Verwendung von OrderByDescending nicht ändert. Ebenso wird Elementen mit einem Index, der größer als der angegebene Bereich ist, Int32.MinValue zugewiesen, damit sie erscheinen am Ende des Bestellvorgangs. Allen Elementen innerhalb des angegebenen Bereichs wird ihr normaler Index zugewiesen und entsprechend umgekehrt.

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

Verwendung:

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

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

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

Ich bin mir nicht sicher, welche Leistungseinbußen diese Linq-Implementierungen gegenüber der Verwendung einer temporären Liste zum Umschließen einer Sammlung zum Umkehren haben.

Zum Zeitpunkt des Schreibens war mir die Reverse-Implementierung von Linq nicht bekannt, aber es hat Spaß gemacht, dies herauszufinden. https://msdn.microsoft.com/en-us/library/vstudio/bb358497(v=vs.100).aspx

Wenn Sie eine Liste <T> verwenden, können Sie auch diesen Code verwenden:

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

Dies ist eine Methode, die die Liste in sich selbst umgekehrt schreibt.

Nun zum foreach:

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

Die Ausgabe ist:

3
2
1

Es ist möglich, wenn Sie den Sammlungscode ändern können, der IEnumerable oder IEnumerable implementiert (z. B. Ihre eigene Implementierung von IList).

Erstellen Sie einen Iterator , der diesen Job für Sie ausführt , z. B. die folgende Implementierung über die IEnumerable- Schnittstelle (vorausgesetzt, 'items' ist in diesem Beispiel ein Listenfeld ):

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

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

Aus diesem Grund wird Ihre Liste in umgekehrter Reihenfolge durch Ihre Liste iteriert.

Nur ein Hinweis: Sie sollten dieses spezielle Verhalten Ihrer Liste in der Dokumentation klar angeben (noch besser, indem Sie einen selbsterklärenden Klassennamen wie Stack oder Queue wählen).

Nein. ForEach durchläuft nur die Sammlung für jeden Artikel und die Reihenfolge hängt davon ab, ob IEnumerable oder GetEnumerator () verwendet wird.

Wenn man die nette Antwort von Jon Skeet leicht herausarbeitet , könnte dies vielseitig sein:

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

Und dann verwenden als

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

Ich habe diesen Code verwendet, der funktioniert hat

                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) {

Das funktioniert ziemlich gut

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