W jakiej kolejności C # for each loop iteruje po List <T>?

Zastanawiałem się nad kolejnością, w jakiej pętla foreach w języku C # przechodzi przez System.Collections.Generic.List<T>obiekt.

Znalazłem kolejne pytanie na ten sam temat, ale nie czuję, że odpowiada na moje pytanie w sposób satysfakcjonujący.

Ktoś twierdzi, że nie określono żadnego porządku. Ale jak twierdzi ktoś inny, kolejność przechodzenia przez tablicę jest stała (od 0 do Length-1). 8.8.4 Oświadczenie foreach

Mówiono też, że to samo dotyczy wszystkich klas standardowych z kolejnością (np List<T>.). Nie mogę znaleźć żadnej dokumentacji, która by to potwierdzała. Więc z tego co wiem, teraz może tak działać, ale może w następnej wersji .NET będzie inaczej (nawet jeśli może to być mało prawdopodobne).

Spojrzałem też na List(t).Enumeratordokumentację bez powodzenia.

Inne powiązane pytanie stwierdza, że ​​w przypadku języka Java jest to wyraźnie wymienione w dokumentacji:

List.iterator()zwraca iterator po elementach tej listy w odpowiedniej kolejności. "

Szukam czegoś takiego w dokumentacji C #.

Z góry dziękuję.

Edycja: Dziękuję wszystkim za wszystkie odpowiedzi (niesamowite, jak szybko otrzymałem tak wiele odpowiedzi). Ze wszystkich odpowiedzi rozumiem, że List<T>zawsze zmienia się kolejność indeksowania. Ale nadal chciałbym zobaczyć wyraźny spokój dokumentacji stwierdzającej to, podobnie jak w dokumentacji JavaList .

Na stronie Microsoft Reference Source dla List<T>Enumerator jest wyraźnie stwierdzone, że iteracja jest wykonywana od 0 do Length-1:

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

Mam nadzieję, że to nadal jest dla kogoś istotne

Zasadniczo jest to aż do IEnumeratorrealizacji - ale na List<T>to zawsze iść w naturalnym porządkiem listy, czyli takiej samej kolejności jak w indekser: list[0], list[1], list[2]itd.

Nie wierzę, że jest to wyraźnie udokumentowane - przynajmniej nie znalazłem takiej dokumentacji - ale myślę, że można to traktować jako gwarantowane. Jakakolwiek zmiana w tej kolejności bezcelowo złamałaby wszystkie rodzaje kodu. W rzeczywistości byłbym zaskoczony, widząc, że jakakolwiek implementacja jest IList<T>niezgodna z tym. Trzeba przyznać, że fajnie byłoby zobaczyć to szczegółowo udokumentowane ...

W linku zaakceptowana odpowiedź stwierdza w specyfikacji języka C # w wersji 3.0, strona 240 :

Kolejność, w jakiej każdy przechodzi przez elementy tablicy, jest następująca: W przypadku tablic jednowymiarowych elementy przechodzą w rosnącej kolejności indeksów, zaczynając od indeksu 0, a kończąc na indeksie Długość - 1. W przypadku tablic wielowymiarowych przechodzą elementy tak, że indeksy wymiaru znajdującego się najbardziej na prawo są zwiększane najpierw, potem następny lewy wymiar i tak dalej w lewo. Poniższy przykład wyświetla każdą wartość w dwuwymiarowej tablicy w kolejności elementów:

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

Uzyskany wynik jest następujący: 1,2 2,3 3,4 4,5 5,6 6,7 7,8 8,9 W tym przykładzie

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.

Kolejność jest definiowana przez iterator używany do przechodzenia przez kolekcję danych przy użyciu pętli foreach.

Jeśli używasz standardowej kolekcji, którą można indeksować (na przykład listy), przejdzie ona do kolekcji, zaczynając od indeksu 0 i przesuwając się w górę.

Jeśli chcesz kontrolować kolejność, możesz albo kontrolować sposób obsługi iteracji kolekcji, implementując własny IEnumerable , albo sortować listę tak, jak chcesz, przed wykonaniem pętli foreach.

To wyjaśnia, jak Enumerator działa dla ogólnej listy. Początkowo bieżący element jest niezdefiniowany i używa MoveNext, aby przejść do następnego elementu.

Jeśli przeczytasz MoveNext , oznacza to, że rozpocznie się od pierwszego elementu kolekcji, a stamtąd przejdzie do następnego, aż osiągnie koniec kolekcji.

Listy wydają się zwracać elementy w kolejności, w jakiej znajdują się w magazynie zapasowym - więc jeśli zostaną dodane do listy w ten sposób, zostaną zwrócone w ten sposób.

Jeśli Twój program zależy od kolejności, możesz chcieć posortować go przed przejściem przez listę.

To trochę głupie w przypadku wyszukiwania liniowego - ale jeśli potrzebujesz zamówienia w określony sposób, najlepszym rozwiązaniem jest wykonanie elementów w tej kolejności.

Po prostu musiałem zrobić coś podobnego do szybkiego hackowania kodu, chociaż nie zadziałało to w przypadku tego, co próbowałem zrobić, zmieniło kolejność listy dla mnie.

Używanie LINQ do zmiany kolejności

         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