C # foreach améliorations?

Je rencontre cela souvent pendant la programmation où je veux avoir un index de comptage de boucles à l'intérieur d'un foreach et devoir créer un entier, l'utiliser, l'incrémenter, etc. Ne serait-ce pas une bonne idée s'il y avait un mot-clé introduit qui était le nombre de boucles à l'intérieur d'un foreach? Il pourrait également être utilisé dans d'autres boucles.

Est-ce que cela va à l'encontre de l'utilisation de mots clés, car le compilateur ne permettrait pas que ce mot clé soit utilisé ailleurs que dans une construction en boucle?

Si vous avez besoin d'un nombre de boucles à l'intérieur d'une foreachboucle, pourquoi ne pas simplement utiliser une forboucle régulière . La foreachboucle était destinée à forsimplifier les utilisations spécifiques des boucles. Il semble que vous ayez une situation où la simplicité du foreachn'est plus bénéfique.

Vous pouvez utiliser des types anonymes comme celui-ci

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

Ceci est similaire à la enumeratefonction de Python

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

J'ajoute simplement la réponse de Dan Finch ici, comme demandé.

Ne me donne pas de points, donne des points à Dan Finch :-)

La solution consiste à écrire la méthode d'extension générique suivante:

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

Qui est utilisé comme ça:

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

Je peux me tromper à ce sujet, mais j'ai toujours pensé que le point principal de la boucle foreach était de simplifier l'itération à partir des jours STL de C ++, c'est-à-dire

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

comparer cela à l'utilisation par INET de IEnumerable dans foreach

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

ce dernier est beaucoup plus simple et évite bon nombre des pièges anciens. De plus, ils semblent suivre des règles presque identiques. Par exemple, vous ne pouvez pas modifier le contenu IEnumerable à l'intérieur de la boucle (ce qui est beaucoup plus logique si vous y pensez de la manière STL). Cependant, la boucle for a souvent un objectif logique différent de celui de l'itération.

Si la collection en question est un IList<T>, vous pouvez simplement utiliser foravec l'indexation:

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

Sinon, alors vous pourriez utiliser Select(), il a une surcharge qui vous donne l'index.

Si cela ne convient pas non plus, je pense que maintenir cet index manuellement est assez simple, ce ne sont que deux très courtes lignes de code. Créer un mot clé spécifiquement pour cela serait une exagération.

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

Si tout ce que vous savez, c'est que la collection est un IEnumerable, mais que vous devez garder une trace du nombre d'éléments que vous avez traités jusqu'à présent (et donc du total lorsque vous avez terminé), vous pouvez ajouter quelques lignes à une boucle for de base:

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
}

Vous pouvez également ajouter une variable d'index incrémentée à une foreach:

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

Si vous souhaitez rendre ce look plus élégant, vous pouvez définir une ou deux méthodes d'extension pour "masquer" ces détails:

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

La portée fonctionne également si vous voulez garder le bloc propre des collisions avec d'autres noms ...

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

Pour cela, j'utilise une whileboucle. Les boucles avec forfonctionnent également, et beaucoup de gens semblent les préférer, mais j'aime seulement les utiliser foravec quelque chose qui aura un nombre fixe d'itérations. IEnumerables peuvent être générés au moment de l'exécution, donc, à mon avis, whileest plus logique. Appelez cela une directive de codage informelle, si vous le souhaitez.