C # przewidywać ulepszenia?

Często spotykam się z tym podczas programowania, w którym chcę mieć indeks liczby pętli w foreach i muszę utworzyć liczbę całkowitą, użyć go, zwiększyć itd. Czy nie byłoby dobrym pomysłem, gdyby wprowadzono słowo kluczowe, które było liczba pętli w foreach? Może być również używany w innych pętlach.

Czy stoi to w sprzeczności ze stosowaniem słów kluczowych, ponieważ kompilator nie pozwala na użycie tego słowa kluczowego nigdzie indziej niż w konstrukcji pętli?

Jeśli potrzebujesz liczby pętli w foreachpętli, skorzystaj z zwykłej forpętli. foreachPętlowy przeznaczone do specyficznych zastosowań forpętli prostsze. Wygląda na to, że masz sytuację, w której prostota foreachnie jest już korzystna.

Możesz użyć takich anonimowych typów

foreach (var item in items.Select((v, i) => new { Value = v, Index = i }))
{
    Console.WriteLine("Item value is {0} and index is {1}.", item.Value, item.Index);
}

Jest to podobne do enumeratefunkcji Pythona

for i, v in enumerate(items):
    print v, i

Właśnie dodam tutaj odpowiedź Dana Fincha , zgodnie z prośbą.

Nie dawaj mi punktów, dawaj punkty Danowi Finchowi :-)

Rozwiązaniem jest napisanie następującej ogólnej metody rozszerzenia:

public static void Each<T>( this IEnumerable<T> ie, Action<T, int> action )
{
    var i = 0;
    foreach ( var e in ie ) action( e, i++ );
}

Który jest używany tak:

var strings = new List<string>();
strings.Each( ( str, n ) =>
{
    // hooray
} );

Mogę się mylić, ale zawsze myślałem, że głównym celem pętli foreach było uproszczenie iteracji z dni STL C ++, tj.

for(std::stltype<typename>::iterator iter = stl_type_instance.begin(); iter != stl_type_instance.end(); iter++)
{
   //dereference iter to use each object.
}

porównaj to do użycia IEnumerable w .NET w foreach

foreach(TypeName instance in DescendentOfIEnumerable)
{
   //use instance to use the object.
}

ten drugi jest o wiele prostszy i pozwala uniknąć wielu starych pułapek. Ponadto wydają się przestrzegać prawie identycznych zasad. Na przykład nie można zmienić zawartości IEnumerable wewnątrz pętli (co ma o wiele większy sens, jeśli myślisz o tym w sposób STL). Pętla for ma jednak często inny logiczny cel niż iteracja.

Jeśli chodzi o kolekcję IList<T>, możesz po prostu użyć jej fordo indeksowania:

for (int i = 0; i < collection.Count; i++)
{
    var item = collection[i];
    // …
}

Jeśli nie, to możesz użyć Select(), ma przeciążenie, które daje indeks.

Jeśli to również nie jest odpowiednie, myślę, że ręczne utrzymanie tego indeksu jest dość proste, to tylko dwie bardzo krótkie linie kodu. Utworzenie słowa kluczowego specjalnie w tym celu byłoby przesadą.

int i = 0;
foreach (var item in collection)
{
    // …
    i++;
}

Jeśli wszystko, co wiesz, to, że kolekcja jest IEnumerable, ale musisz śledzić, ile elementów przetworzyłeś do tej pory (a tym samym sumę po zakończeniu), możesz dodać kilka linii do podstawowej pętli for:

var coll = GetMyCollectionAsAnIEnumerable();
var idx = 0;
for(var e = coll.GetEnumerator(); e.MoveNext(); idx++)
{
   var elem = e.Current;

   //use elem and idx as you please
}

Możesz także dodać przyrostową zmienną indeksu do foreach:

var i=0;
foreach(var elem in coll)
{
   //do your thing, then...
   i++;
}

Jeśli chcesz, aby wyglądał bardziej elegancko, możesz zdefiniować metodę rozszerzenia lub dwie, aby „ukryć” te szczegóły:

public static void ForEach<T>(this IEnumerable<T> input, Action<T> action)
{
    foreach(T elem in input)
        action(elem);
}

public static void ForEach<T>(this IEnumerable<T> input, Action<T, int> action)
{
    var idx = 0;
    foreach(T elem in input)
        action(elem, idx++); //post-increment happens after parameter-passing
}

//usage of the index-supporting method
coll.ForEach((e, i)=>Console.WriteLine("Element " + (i+1) + ": " + e.ToString()));

Scoping działa również, jeśli chcesz utrzymać blok w czystości przed kolizjami z innymi nazwami ...

{ int index = 0; foreach(var el in List) { Console.WriteLine(el + " @ " + index++); } }

Do tego używam whilepętli. Pętle forrównież działają, i wydaje się, że wiele osób je preferuje, ale lubię używać tylko forz czymś, co będzie miało określoną liczbę iteracji. IEnumerables mogą być generowane w czasie wykonywania, więc moim zdaniem whilema to większy sens. Jeśli chcesz, nazwij to nieformalną wytyczną kodowania.