C # für jede Verbesserung?

Ich stoße beim Programmieren häufig darauf, wenn ich einen Loop-Count-Index in einem foreach haben möchte und eine Ganzzahl erstellen, verwenden, inkrementieren usw. Wäre es nicht eine gute Idee, wenn ein Schlüsselwort eingeführt würde Die Anzahl der Schleifen in einem Foreach? Es kann auch in anderen Loops verwendet werden.

Verstößt dies gegen die Verwendung von Schlüsselwörtern, da der Compiler zulässt, dass dieses Schlüsselwort nur in einem Schleifenkonstrukt verwendet wird?

Wenn Sie eine Schleifenzahl innerhalb einer foreachSchleife benötigen, verwenden Sie einfach eine reguläre forSchleife. Die foreachSchleife sollte die spezifische Verwendung von forSchleifen vereinfachen. Es hört sich so an, als hätten Sie eine Situation, in der die Einfachheit des foreachnicht mehr von Vorteil ist.

Sie können solche anonymen Typen verwenden

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

Dies ähnelt der Python- enumerateFunktion

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

Ich füge hier nur die Antwort von Dan Finch hinzu , wie gewünscht.

Gib mir keine Punkte, gib Dan Finch Punkte :-)

Die Lösung besteht darin, die folgende generische Erweiterungsmethode zu schreiben:

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

Welches wird so verwendet:

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

Ich kann mich irren, aber ich dachte immer, dass der Hauptpunkt der foreach-Schleife darin bestand, die Iteration aus den STL-Tagen von C ++ zu vereinfachen, d. H.

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

Vergleichen Sie dies mit der Verwendung von IEnumerable in foreach durch .NET

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

Letzteres ist viel einfacher und vermeidet viele der alten Fallstricke. Außerdem scheinen sie fast identischen Regeln zu folgen. Zum Beispiel können Sie den IEnumerable-Inhalt nicht ändern, während Sie sich in der Schleife befinden (was viel sinnvoller ist, wenn Sie es auf STL-Weise betrachten). Die for-Schleife hat jedoch häufig einen anderen logischen Zweck als die Iteration.

Wenn es sich bei der fraglichen Sammlung um eine handelt IList<T>, können Sie sie einfach formit der Indizierung verwenden:

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

Wenn nicht, dann könnten Sie verwenden Select(), es hat eine Überladung, die Ihnen den Index gibt.

Wenn das auch nicht geeignet ist, denke ich, dass es einfach genug ist, diesen Index manuell zu pflegen. Es sind nur zwei sehr kurze Codezeilen. Das Erstellen eines Schlüsselworts speziell dafür wäre ein Overkill.

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

Wenn Sie nur wissen, dass es sich bei der Sammlung um eine IEnumerable handelt, Sie jedoch nachverfolgen müssen, wie viele Elemente Sie bisher verarbeitet haben (und damit die Gesamtzahl, wenn Sie fertig sind), können Sie einer grundlegenden for-Schleife ein paar Zeilen hinzufügen:

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
}

Sie können einem foreach auch eine inkrementierte Indexvariable hinzufügen:

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

Wenn Sie dies eleganter gestalten möchten, können Sie eine oder zwei Erweiterungsmethoden definieren, um diese Details zu "verbergen":

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

Das Scoping funktioniert auch, wenn Sie den Block frei von Kollisionen mit anderen Namen halten möchten ...

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

Dafür benutze ich eine whileSchleife. Schleifen forfunktionieren auch, und viele Leute scheinen sie zu bevorzugen, aber ich verwende sie nur gerne formit etwas, das eine feste Anzahl von Iterationen hat. IEnumerables kann zur Laufzeit generiert werden, whilewas meiner Meinung nach sinnvoller ist. Nennen Sie es eine informelle Codierungsrichtlinie, wenn Sie möchten.