C# foreach improvements?

Question

I run into this often during programming where I want to have a loop count index inside of a foreach and have to create an integer, use it, increment, etc. Wouldn't it be a good idea if there was a keyword introduced that was the loop count inside of a foreach? It could also be used in other loops as well.

Does this go against the use of keywords seeing as how the compiler would not allow this keyword used anywhere but in a loop construct?

Answer 1

If you need a loop count inside a foreach loop why don't you just use a regular for loop. The foreach loop was intended to make specific uses of for loops simpler. It sounds like you have a situation where the simplicity of the foreach is no longer beneficial.

Answer 2

You can use anonymous types like this

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

This is similar to Python's enumerate function

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

Answer 3

I'm just adding Dan Finch's answer here, as requested.

Don't give me points, give points to Dan Finch :-)

The solution is to write the following generic extension method:

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

Which is used like so:

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

Answer 4

I may be wrong about this, but I always thought that the main point of the foreach loop was to simplify iteration from the STL days of C++ i.e.

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

compare this to .NET's use of IEnumerable in the foreach

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

the latter is much simpler and avoids many of the old pitfalls. In addition, they seem to follow almost identical rules. For instance you can't change the the IEnumerable contents while inside the loop (which makes much more sense if you think of it the STL way). However, the for loop often has a different logical purpose than iteration.

Answer 5

If the collection in question is an IList<T>, you can simply use for with indexing:

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

If not, then you could use Select(), it has an overload that gives you the index.

If that's also not suitable, I think maintaining that index manually is simple enough, it's just two very short lines of code. Creating a keyword specifically for this would be an overkill.

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

Answer 6

If all you know is that the collection is an IEnumerable, but need to keep track of how many elements you have processed so far (and thus the total when you're done), you can add a couple lines to a basic for loop:

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
}

You can also add an incremented index variable to a foreach:

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

If you want to make this look more elegant, you can define an extension method or two to "hide" these details:

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

Answer 7

Scoping also works if you want to keep the block clean of collisions with other names...

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

Answer 8

For this I use a while loop. Loops with for also work, and many people seem to prefer them, but I only like to use for with something that will have a fixed number of iterations. IEnumerables may be generated at run time, so, to my mind, while makes more sense. Call it an informal coding guideline, if you like.