In welcher Reihenfolge iteriert ein C # für jede Schleife über eine Liste <T>?

Ich habe mich über die Reihenfolge gewundert, in der eine foreach-Schleife in C # ein System.Collections.Generic.List<T>Objekt durchläuft .

Ich habe eine andere Frage zum gleichen Thema gefunden, aber ich habe nicht das Gefühl, dass sie meine Frage zu meiner Zufriedenheit beantwortet.

Jemand gibt an, dass keine Reihenfolge definiert ist. Aber wie jemand anderes sagt, ist die Reihenfolge, in der ein Array durchlaufen wird, fest (von 0 bis Länge 1). 8.8.4 Die foreach-Anweisung

Es wurde auch gesagt, dass das Gleiche für alle Standardklassen mit einer Bestellung gilt (z List<T>. B. ). Ich kann keine Dokumentation finden, um das zu sichern. Soweit ich weiß, könnte es jetzt so funktionieren, aber vielleicht wird es in der nächsten .NET-Version anders sein (auch wenn es unwahrscheinlich ist).

Ich habe mir auch die List(t).EnumeratorDokumentation ohne Glück angesehen.

Eine andere verwandte Frage besagt, dass Java speziell in der Dokumentation erwähnt wird:

List.iterator()Gibt einen Iterator über die Elemente in dieser Liste in der richtigen Reihenfolge zurück. "

Ich suche so etwas in der C # -Dokumentation.

Danke im Voraus.

Bearbeiten: Vielen Dank für all Ihre Antworten (erstaunlich, wie schnell ich so viele Antworten erhalten habe). Was ich aus allen Antworten verstehe, ist, dass List<T>es immer in der Reihenfolge seiner Indizierung iteriert. Trotzdem würde ich mir eine klare Dokumentation wünschen, die dies ähnlich wie die Java-Dokumentation auf beschreibtList .

Auf der Microsoft-Referenzquellenseite für List<T>Enumerator wird ausdrücklich angegeben, dass die Iteration von 0 bis Länge 1 erfolgt:

internal Enumerator(List<T> list) {
    this.list = list;
    index = 0;
    version = list._version;
    current = default(T);
}

public bool MoveNext() {

    List<T> localList = list;

    if (version == localList._version && ((uint)index < (uint)localList._size)) 
    {                                                     
        current = localList._items[index];                    
        index++;
        return true;
    }
    return MoveNextRare();
}

Hoffe, es ist immer noch relevant für jemanden

Im Grunde ist es auf die oben IEnumeratorUmsetzung - aber für einen List<T>wird es immer in der natürlichen Reihenfolge der Liste gehen, dh die gleiche Reihenfolge wie die Indexer: list[0], list[1], list[2]usw.

Ich glaube nicht, dass es explizit dokumentiert ist - zumindest habe ich eine solche Dokumentation nicht gefunden -, aber ich denke, Sie können sie als garantiert behandeln. Jede Änderung dieser Reihenfolge würde sinnlos alle Arten von Code zerstören. Tatsächlich wäre ich überrascht zu sehen, welche Implementierung IList<T>dies missachtete. Zugegeben, es wäre schön, wenn es speziell dokumentiert wäre ...

In Ihrem Link heißt es in der akzeptierten Antwort in C # Language Specification Version 3.0, Seite 249 :

Die Reihenfolge, in der foreach die Elemente eines Arrays durchläuft, lautet wie folgt: Bei eindimensionalen Arrays werden Elemente in aufsteigender Indexreihenfolge durchlaufen, beginnend mit Index 0 und endend mit Indexlänge - 1. Bei mehrdimensionalen Arrays werden Elemente durchlaufen so dass die Indizes der Dimension ganz rechts zuerst erhöht werden, dann die nächste Dimension links und so weiter nach links. Im folgenden Beispiel wird jeder Wert in einem zweidimensionalen Array in Elementreihenfolge ausgedruckt:

using System;
class Test
{
  static void Main() {
      double[,] values = {
          {1.2, 2.3, 3.4, 4.5},
          {5.6, 6.7, 7.8, 8.9}
      };
      foreach (double elementValue in values)
          Console.Write("{0} ", elementValue);
      Console.WriteLine();
  }
}

Die erzeugte Ausgabe ist wie folgt: 1.2 2.3 3.4 4.5 5.6 6.7 7.8 8.9 Im Beispiel

int[] numbers = { 1, 3, 5, 7, 9 };
foreach (var n in numbers) Console.WriteLine(n);
the type of n is inferred to be int, the element type of numbers.

Die Reihenfolge wird durch den Iterator definiert, der zum Durchlaufen einer Datensammlung mithilfe einer foreach-Schleife verwendet wird.

Wenn Sie eine indexierbare Standardsammlung verwenden (z. B. eine Liste), wird die Sammlung beginnend mit Index 0 durchlaufen und nach oben verschoben.

Wenn Sie die Reihenfolge steuern müssen, können Sie entweder steuern, wie die Iteration der Sammlung behandelt wird, indem Sie Ihre eigene IEnumerable implementieren , oder Sie können die Liste nach Ihren Wünschen sortieren, bevor Sie die foreach-Schleife ausführen.

Dies erklärt, wie Enumerator für generische Listen funktioniert. Das aktuelle Element ist zunächst undefiniert und verwendet MoveNext, um zum nächsten Element zu gelangen.

Wenn Sie MoveNext lesen, bedeutet dies, dass es mit dem ersten Element der Sammlung beginnt und von dort zum nächsten wechselt, bis es das Ende der Sammlung erreicht.

Listen scheinen die Artikel in einer Reihenfolge zurückzugeben, in der sie sich im Hintergrundspeicher befinden. Wenn sie also auf diese Weise zur Liste hinzugefügt werden, werden sie auf diese Weise zurückgegeben.

Wenn Ihr Programm von der Reihenfolge abhängt, können Sie es sortieren, bevor Sie die Liste durchlaufen.

Es ist etwas albern für lineare Suchen - aber wenn Sie die Bestellung auf eine bestimmte Weise benötigen, ist es am besten, die Artikel in dieser Reihenfolge zu machen.

Ich musste nur etwas Ähnliches wie einen schnellen Hack von Code tun, obwohl es für das, was ich versuchte, nicht funktionierte, aber die Liste für mich neu ordnete.

Verwenden von LINQ zum Ändern der Reihenfolge

         DataGridViewColumn[] gridColumns = new DataGridViewColumn[dataGridView1.Columns.Count];
         dataGridView1.Columns.CopyTo(gridColumns, 0); //This created a list of columns

         gridColumns = (from n in gridColumns
                        orderby n.DisplayIndex descending
                        select n).ToArray(); //This then changed the order based on the displayindex