I like this idea, we just need to make sure this won't conflict with the destructuring assignment syntax.

If tuples are added as first-class citizens to the language, this could be replaced by an extension method on IEnumerable<T>, without the need for special syntax.

@orthoxerox Probably not, the existing consensus in so far in #6400 seems to lean towards using let.

@SolalPirelli Good point. I assume you mean something like this:

static void ForEach(this IEnumerable<T> source, Action<T, int> action)
{
    int count = 0;
    foreach (var item in source) action(item, count++);
}

I agree that would be less work than implementing a new language feature. It would be kinda strange to newcomers though, since you would have some people writing foreach and others writing ForEach. It's better to provide just one syntax for consistency.

ninja edit Eric Lippert has a blog post on this: https://blogs.msdn.microsoft.com/ericlippert/2009/05/18/foreach-vs-foreach/

What's wrong with GetItems().Select((item,index) => { ... })?

@jamesqo No, I meant an IEnumerable<T * int> Indexed(this IEnumerable<T> source) method, which would then be iterated using foreach(var (item, index) in stuff.Indexed()) { ... }.

@alrz Because Select has to return something (the return type can't be void), so your code would end up looking like this:

items.Select((item, i) =>
{
    // work
    return 0;
});

edit Also not to mention Select is lazy so you'd have to iterate through it to see any side effects.

@SolalPirelli Hmm, seems interesting. Would it be possible to omit the parentheses in the tuple declaration?

@jamesqo @SolalPirelli That was proposed in #6067 but it seemingly dismissed. Then you have to do this:

foreach(var tuple in list.Indexed()) {
  let (var item, var index) = tuple;
  // ...
}

/* Running out of variable names... we have to keep coming
up with new ones like idx or ind, which creates ambiguity */

You could try more meaningful variable names than 'index'. In your example, 'indexItems1' and 'indexItems2' would be a better name. Further, if you're not using the value of 'indexItems1' after the loop you could just use index over and over. Or you could do this.

foreach (var indexedValue in SomeList.Select((e, i) => Tuple.Create(e,i)))
     ....

@Blecki See my updated post. Your solution would definitely work, I just don't think it's readable as it could be.

In your example, 'indexItems1' and 'indexItems2' would be a better name.

Well, I guess it's a matter of opinion. But let's be honest, would you rather have code that looks like this:

int indexItems1 = 0;
foreach (var item in items1)
{
    // do something...
    indexItems1++;
}

int indexItems2 = 0;
foreach (var item in items2)
{
    // do something...
    indexItems2++;
}

or this:

foreach (var item, index in items1)
    // do something...

foreach (var item, index in items2)
    // do something...

if you're not using the value of 'indexItems1' after the loop you could just use index over and over

Yeah, but if you accidentally forget to reset index to 0 then you may run into problems, e.g.

int i = 0;
foreach (var item in items1) { /* */ i++; }

// Forgot to reset i = 0...
foreach (var item in items2)
{
    // Whoops! Now i starts at items1.Count() and continues from there.
    i++;
}

As the OP points out, this is morally similar to existing issues (#1651, #1752, and #5194), but I'll leave this open for a bit for discussion.

If you are going to do this there needs to be a "Finally" so I can access the index.

@jamesqo, I can't argue with the readability. I avoid tuples because the names 'item1' and 'item2' are meaningless.

How about a mashup of both for and foreach:

foreachindex(var item in collection, int i = 0, i++)
{
    Console.WriteLine("item={0}  index={1}", item, i);
}

This gives you the freedom to change the behavior of the index if you wanted to for some reason:

foreachindex(var record in records, long pos = 0, pos += 20)
{
    Console.WriteLine("record={0}  byte position={1}", record , pos);
}

In fact, you wouldn't even need "foreachindex", just overload the foreach function to accept the additional arguments:

foreach(var target in targets, double dist = 1000, dist -= 50.55 )
{
    Console.WriteLine("target={0}  distance={1} feet", target, dist);
}

@techman2553 I'm not convinced, the whole point of this proposal was to eliminate the boilerplate and the need for a state variable. Your suggestion seems to just move it to a different place (inside the foreach loop).

@GeirGrusom Your solution is good, but there's still a need to write out Select(IndexedElement<T>.Map) every time you want the index, which aside from being repetitive can create overhead (since LINQ uses iteration). Also, it'd be preferable to capture the index/value in 2 variables, rather than wrapping them in one.

The general consensus so far seems to be "we don't need this." If we choose not to go ahead with this proposal, I think we should reconsider the earlier suggestion about using the new destructuring syntax in loops. That would allow us to do something like this:

foreach (let (thing, i) in things.Index())
{
    // do something with thing and i
}

Although it's definitely a bit more verbose than my proposal above, it would support the scenario with no new syntax additions to the language (at least, after tuples/destructuring assignments are added in C# 7).

Correct me if I'm wrong, but wouldn't it be:

foreach ((var item, var index) in things.Index())
{
    // do something with item and index
}

@RichiCoder1 You can't use patterns in foreach.

For reference, 'de-structuring foreach' did end up being allowed, eg. this is ok:

foreach (var (item, index) in things.Indexed())
{
    // do something with item and index
}

Neither linq or morelinq have the "Indexed()" method though. An straightforward but inefficient implementation would be:

public static IEnumerable<(TItem item, int index)> Indexed<TItem>(this IEnumerable<TItem> items)
    => items.Select((item, index) => (item, index));