C # foreach mejoras?

Me encuentro con esto a menudo durante la programación donde quiero tener un índice de conteo de bucles dentro de un foreach y tengo que crear un número entero, usarlo, incrementar, etc. ¿No sería una buena idea si se introdujera una palabra clave que fuera el bucle cuenta dentro de un foreach? También podría usarse en otros bucles también.

¿Esto va en contra del uso de palabras clave, ya que el compilador no permitiría que esta palabra clave se usara en otro lugar sino en una construcción de bucle?

Si necesita un recuento de bucles dentro de un foreachbucle, ¿por qué no utiliza un forbucle normal ? El foreachbucle estaba destinado a simplificar los usos específicos de los forbucles. Parece que tiene una situación en la que la simplicidad de la foreachya no es beneficiosa.

Puedes usar tipos anónimos como este

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

Esto es similar a la enumeratefunción de Python

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

Solo estoy agregando la respuesta de Dan Finch aquí, según lo solicitado.

No me des puntos, da puntos a Dan Finch :-)

La solución es escribir el siguiente método de extensión genérico:

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

Que se usa así:

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

Puedo estar equivocado sobre esto, pero siempre pensé que el punto principal del bucle foreach era simplificar la iteración de los días STL de C ++, es decir

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

compare esto con el uso de .NET de IEnumerable en el foreach

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

este último es mucho más simple y evita muchas de las viejas trampas. Además, parecen seguir reglas casi idénticas. Por ejemplo, no puede cambiar el contenido IEnumerable mientras está dentro del bucle (lo que tiene mucho más sentido si lo piensa de la manera STL). Sin embargo, el bucle for a menudo tiene un propósito lógico diferente al de la iteración.

Si la colección en cuestión es una IList<T>, simplemente puede usar forcon indexación:

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

Si no, entonces podría usarlo Select(), tiene una sobrecarga que le da el índice.

Si eso tampoco es adecuado, creo que mantener ese índice manualmente es bastante simple, son solo dos líneas de código muy cortas. Crear una palabra clave específicamente para esto sería una exageración.

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

Si todo lo que sabe es que la colección es un IEnumerable, pero necesita realizar un seguimiento de cuántos elementos ha procesado hasta ahora (y, por lo tanto, el total cuando haya terminado), puede agregar un par de líneas a un bucle básico:

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
}

También puede agregar una variable de índice incremental a un foreach:

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

Si desea que esto se vea más elegante, puede definir uno o dos métodos de extensión para "ocultar" estos detalles:

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

El alcance también funciona si desea mantener el bloque limpio de colisiones con otros nombres ...

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

Para esto uso un whilebucle. Los bucles fortambién funcionan, y muchas personas parecen preferirlos, pero solo me gusta usarlos forcon algo que tenga un número fijo de iteraciones. IEnumerables puede generarse en tiempo de ejecución, por lo que, en mi opinión, whiletiene más sentido. Llámelo una directriz informal de codificación, si lo desea.