How do you get the index of the current iteration of a foreach loop

Question

Is there some rare language construct I haven t encountered  like the few I ve learned recently  some on Stack Overflow  in C  to get a value representing the current iteration of a foreach loop   For instance  I currently do something like this depending on the circumstances   int i   0  foreach  Object o in collection                   i

User · Answer

i want to discuss this question more theoretically (since it has already enough practical answers)

.net has a very nice abstraction model for groups of data (a.k.a. collections)

At the very top, and the most abstract, you have an IEnumerable it's just a group of data that you can enumerate. It doesn't matter HOW you enumerate, it's just that you can enumerate some data. And that enumeration is done by a completely different object, an IEnumerator

these interfaces are defined is as follows:

//
// Summary:
//     Exposes an enumerator, which supports a simple iteration over a non-generic collection.
public interface IEnumerable
{
    //
    // Summary:
    //     Returns an enumerator that iterates through a collection.
    //
    // Returns:
    //     An System.Collections.IEnumerator object that can be used to iterate through
    //     the collection.
    IEnumerator GetEnumerator();
}

//
// Summary:
//     Supports a simple iteration over a non-generic collection.
public interface IEnumerator
{
    //
    // Summary:
    //     Gets the element in the collection at the current position of the enumerator.
    //
    // Returns:
    //     The element in the collection at the current position of the enumerator.
    object Current { get; }

    //
    // Summary:
    //     Advances the enumerator to the next element of the collection.
    //
    // Returns:
    //     true if the enumerator was successfully advanced to the next element; false if
    //     the enumerator has passed the end of the collection.
    //
    // Exceptions:
    //   T:System.InvalidOperationException:
    //     The collection was modified after the enumerator was created.
    bool MoveNext();
    //
    // Summary:
    //     Sets the enumerator to its initial position, which is before the first element
    //     in the collection.
    //
    // Exceptions:
    //   T:System.InvalidOperationException:
    //     The collection was modified after the enumerator was created.
    void Reset();
}

as you might have noticed, the IEnumerator interface doesn't "know" what an index is, it just knows what element it's currently pointing to, and how to move to the next one.
now here is the trick: foreach considers every input collection an IEnumerable, even if it is a more concrete implementation like an IList<T> (which inherits from IEnumerable), it will only see the abstract interface IEnumerable.
what foreach is actually doing, is calling GetEnumerator on the collection, and calling MoveNext until it returns false.
so here is the problem, you want to define a concrete concept "Indices" on an abstract concept "Enumerables", the built in foreach construct doesn't give you that option, so your only way is to define it yourself, either by what you are doing originally (creating a counter manually) or just use an implementation of IEnumerator that recognizes indices AND implement a foreach construct that recognizes that custom implementation.

personally i would create an extension method like this

public static class Ext
{
    public static void FE<T>(this IEnumerable<T> l, Action<int, T> act)
    {
        int counter = 0;
        foreach (var item in l)
        {
            act(counter, item);
            counter++;
        }
    }
}

and use it like this

var x = new List<string>() { "hello", "world" };
x.FE((ind, ele) =>
{
    Console.WriteLine($"{ind}: {ele}");
});

this also avoids any unnecessary allocations seen in other answers.

User · Answer

My solution for this problem is an extension method WithIndex     http   code google com p ub-dotnet-utilities source browse trunk Src Utilities Extensions EnumerableExtensions cs  Use it like  var list   new List lt int gt    1  2  3  4  5  6         var odd   list WithIndex   Where i   gt   i Item  amp  1     1   CollectionAssert AreEqual new     0  2  4    odd Select i   gt  i Index    CollectionAssert AreEqual new     1  3  5    odd Select i   gt  i Item

User · Answer

Ian Mercer posted a similar solution as this on Phil Haack s blog   foreach  var item in Model Select  value  i    gt  new   i  value           var value   item value      var index   item i      This gets you the item  item value  and its index  item i  by using this overload of LINQ s Select      the second parameter of the function  inside Select  represents the index of the source element    The new   i  value   is creating a new anonymous object   Heap allocations can be avoided by using ValueTuple if you re using C  7 0 or later   foreach  var item in Model Select  value  i    gt    value  i           var value   item value      var index   item i      You can also eliminate the item  by using automatic destructuring    lt ol gt  foreach   MyType value  Int32 i  in Model Select  value  i    gt    value  i            lt li id  item  i  gt  value lt  li gt     lt  ol gt

User · Answer

This is how I do it  which is nice for its simplicity brevity  but if you re doing a lot in the loop body obj Value  it is going to get old pretty fast   foreach var obj in collection Select  item  index    gt  new   Index   index  Value   item          string foo   string Format  Something  0      1    obj Index  obj Value

User · Answer

How about something like this   Note that myDelimitedString may be null if myEnumerable is empty   IEnumerator enumerator   myEnumerable GetEnumerator    string myDelimitedString  string current   null   if  enumerator MoveNext         current    string enumerator Current   while  null    current        current    string enumerator Current         myDelimitedString    current       if  enumerator MoveNext             myDelimitedString    DELIMITER      else         break

User · Answer

I disagree with comments that a for loop is a better choice in most cases    foreach is a useful construct  and not replaceble by a for loop in all circumstances    For example  if you have a DataReader and loop through all records using a foreach it automatically calls the Dispose method and closes the reader  which can then close the connection automatically   This is therefore safer as it prevents connection leaks even if you forget to close the reader     Sure it is good practise to always close readers but the compiler is not going to catch it if you don t - you can t guarantee you have closed all readers but you can make it more likely you won t leak connections by getting in the habit of using foreach    There may be other examples of the implicit call of the Dispose method being useful

User · Answer

Just add your own index  Keep it simple   int i   0  foreach  var item in Collection        item index   i        i

User · Answer

There s nothing wrong with using a counter variable  In fact  whether you use for  foreach while or do  a counter variable must somewhere be declared and incremented   So use this idiom if you re not sure if you have a suitably-indexed collection   var i   0  foreach  var e in collection          Do stuff with  e  and  i     i        Else use this one if you know that your indexable collection is O 1  for index access  which it will be for Array and probably for List lt T gt   the documentation doesn t say   but not necessarily for other types  such as LinkedList        Hope the JIT compiler optimises read of the  Count  property  for  var i   0  i  lt  collection Count  i         var e   collection i         Do stuff with  e  and  i      It should never be necessary to  manually  operate the IEnumerator by invoking MoveNext   and interrogating Current - foreach is saving you that particular bother     if you need to skip items  just use a continue in the body of the loop   And just for completeness  depending on what you were doing with your index  the above constructs offer plenty of flexibility   you might use Parallel LINQ      First  filter  e  based on  i      then apply an action to remaining  e  collection      AsParallel        Where  e i    gt     filter with e i          ForAll e   gt       use e  but don t modify it            Using  e  and  i   produce a new collection     where each element incorporates  i  collection      AsParallel        Select  e  i    gt  new MyWrapper e  i      We use AsParallel   above  because it s 2014 already  and we want to make good use of those multiple cores to speed things up  Further  for  sequential  LINQ  you only get a ForEach   extension method on List lt T gt  and Array     and it s not clear that using it is any better than doing a simple foreach  since you are still running single-threaded for uglier syntax

User · Answer

Literal Answer -- warning  performance may not be as good as just using an int to track the index   At least it is better than using IndexOf   You just need to use the indexing overload of Select to wrap each item in the collection with an anonymous object that knows the index   This can be done against anything that implements IEnumerable   System Collections IEnumerable collection   Enumerable Range 100  10    foreach  var o in collection OfType lt object gt    Select  x  i    gt  new  x  i          Console WriteLine   0   1    o i  o x

User · Answer

This doesn t answer your specific question  but it DOES provide you with a solution to your problem  use a for loop to run through the object collection  then you will have the current index you are working on      Untested for  int i   0  i  lt  collection Count  i          Console WriteLine  My index is     i

User · Answer

Unless your collection can return the index of the object via some method  the only way is to use a counter like in your example   However  when working with indexes  the only reasonable answer to the problem is to use a for loop  Anything else introduces code complexity  not to mention time and space complexity

User · Answer

It s only going to work for a List and not any IEnumerable  but in LINQ there s this   IList lt Object gt  collection   new List lt Object gt         new Object         new Object         new Object             foreach  Object o in collection        Console WriteLine collection IndexOf o       Console ReadLine       Jonathan I didn t say it was a great answer  I just said it was just showing it was possible to do what he asked      Graphain I wouldn t expect it to be fast - I m not entirely sure how it works  it could reiterate through the entire list each time to find a matching object  which would be a helluvalot of compares   That said  List might keep an index of each object along with the count   Jonathan seems to have a better idea  if he would elaborate   It would be better to just keep a count of where you re up to in the foreach though  simpler  and more adaptable

User · Answer

Better to use keyword continue safe construction like this  int i -1  foreach  Object o in collection          i                continue     lt --- safe to call  index will be increased

User · Answer

You can write your loop like this   var s    ABCDEFG   foreach  var item in s GetEnumeratorWithIndex          System Console WriteLine  Character   0   Position   1    item Value  item Index       After adding the following struct and extension method   The struct and extension method encapsulate Enumerable Select functionality   public struct ValueWithIndex lt T gt        public readonly T Value      public readonly int Index       public ValueWithIndex T value  int index                this Value   value          this Index   index             public static ValueWithIndex lt T gt  Create T value  int index                return new ValueWithIndex lt T gt  value  index            public static class ExtensionMethods       public static IEnumerable lt ValueWithIndex lt T gt  gt  GetEnumeratorWithIndex lt T gt  this IEnumerable lt T gt  enumerable                return enumerable Select ValueWithIndex lt T gt  Create

User · Answer

I don t think this should be quite efficient  but it works    foreach  var banner in Model MainBanners         Model MainBanners IndexOf banner

User · Answer

I built this in LINQPad   var listOfNames   new List lt string gt     John   Steve   Anna   Chris     var listCount   listOfNames Count   var NamesWithCommas   string Empty   foreach  var element in listOfNames        NamesWithCommas    element      if listOfNames IndexOf element     listCount -1                NamesWithCommas                   NamesWithCommas Dump       LINQPad method to write to console    You could also just use string join   var joinResult   string Join      listOfNames

User · Answer

This answer  lobby the C  language team for direct language support   The leading answer states      Obviously  the concept of an index is foreign to the concept of   enumeration  and cannot be done    While this is true of the current C  language version  2020   this is not a conceptual CLR Language limit  it can be done   The Microsoft C  language development team could create a new C  language feature  by adding support for a new Interface IIndexedEnumerable  foreach  var item in collection with var index        Console WriteLine  Iteration  0  has value  1    index  item        or  building on  user1414213562 s answer foreach  var  item  index  in collection        Console WriteLine  Iteration  0  has value  1    index  item       If foreach    is used and with var index is present  then the compiler expects the item collection to declare IIndexedEnumerable interface  If the interface is absent  the compiler can polyfill wrap the source with an IndexedEnumerable object  which adds in the code for tracking the index   interface IIndexedEnumerable lt T gt    IEnumerable lt T gt          Not index  because sometimes source IEnumerables are transient     public long IterationNumber   get        Later  the CLR can be updated to have internal index tracking  that is only used if with keyword is specified and the source doesn t directly implement IIndexedEnumerable  Why    Foreach looks nicer  and in business applications  foreach loops are rarely a performance bottleneck Foreach can be more efficient on memory  Having a pipeline of functions instead of converting to new collections at each step  Who cares if it uses a few more CPU cycles when there are fewer CPU cache faults and fewer garbage collections  Requiring the coder to add index-tracking code  spoils the beauty It s quite easy to implement  please Microsoft  and is backward compatible   While most people here are not Microsoft employees  this is a correct answer  you can lobby Microsoft to add such a feature  You could already build your own iterator with an extension function and use tuples  but Microsoft could sprinkle the syntactic sugar to avoid the extension function

User · Answer

Here s a solution I just came up with for this problem  Original code   int index 0  foreach  var item in enumerable        blah item  index      some code that depends on the index     index        Updated code  enumerable ForEach  item  index    gt  blah item  index      Extension Method       public static IEnumerable lt T gt  ForEach lt T gt  this IEnumerable lt T gt  enumerable  Action lt T  int gt  action                var unit   new Unit       unit is a new type from the reactive framework  http   msdn microsoft com en-us devlabs ee794896 aspx  to represent a void  since in C  you can t return a void         enumerable Select  item  i    gt                                 action item  i                   return unit                 ToList             return pSource

User · Answer

If the collection is a list  you can use List IndexOf  as in   foreach  Object o in collection                    collection IndexOf o

User · Answer

Using LINQ  C  7  and the System ValueTuple NuGet package  you can do this     foreach  var  value  index  in collection Select  v  i   gt  v  i          Console WriteLine value     is at index     index       You can use the regular foreach construct and be able to access the value and index directly  not as a member of an object  and keeps both fields only in the scope of the loop  For these reasons  I believe this is the best solution if you are able to use C  7 and System ValueTuple

User · Answer

int index  foreach  Object o in collection        index   collection indexOf o       This would work for collections supporting IList

User · Answer

The foreach is for iterating over collections that implement IEnumerable  It does this by calling GetEnumerator on the collection  which will return an Enumerator  This Enumerator has a method and a property   MoveNext   Current  Current returns the object that Enumerator is currently on  MoveNext updates Current to the next object  The concept of an index is foreign to the concept of enumeration  and cannot be done  Because of that  most collections are able to be traversed using an indexer and the for loop construct  I greatly prefer using a for loop in this situation compared to tracking the index with a local variable

User · Answer

For interest  Phil Haack just wrote an example of this in the context of a Razor Templated Delegate  http   haacked com archive 2011 04 14 a-better-razor-foreach-loop aspx   Effectively he writes an extension method which wraps the iteration in an  IteratedItem  class  see below  allowing access to the index as well as the element during iteration   public class IndexedItem lt TModel gt      public IndexedItem int index  TModel item        Index   index      Item   item         public int Index   get  private set      public TModel Item   get  private set        However  while this would be fine in a non-Razor environment if you are doing a single operation  i e  one that could be provided as a lambda  it s not going to be a solid replacement of the for foreach syntax in non-Razor contexts

User · Answer

I wasn t sure what you were trying to do with the index information based on the question  However  in C   you can usually adapt the IEnumerable Select method to get the index out of whatever you want  For instance  I might use something like this for whether a value is odd or even   string   names      one    two    three     var oddOrEvenByName   names      Select  name  index    gt  new KeyValuePair lt string  int gt  name  index   2        ToDictionary kvp   gt  kvp Key  kvp   gt  kvp Value     This would give you a dictionary by name of whether the item was odd  1  or even  0  in the list

User · Answer

I don t believe there is a way to get the value of the current iteration of a foreach loop   Counting yourself  seems to be the best way   May I ask  why you would want to know   It seems that you would most likley be doing one of three things   1   Getting the object from the collection  but in this case you already have it   2   Counting the objects for later post processing   the collections have a Count property that you could make use of   3   Setting a property on the object based on its order in the loop   although you could easily be setting that when you added the object to the collection

User · Answer

This way you can use the index and value using LINQ   ListValues Select  x  i    gt  new   Value   x  Index   i    ToList   ForEach element   gt                   element Index            element Value

User · Answer

using foreach loop how to get index number       foreach  var result in results Select  value  index    gt  new   index  value                  do something

User · Answer

Could do something like this   public static class ForEachExtensions       public static void ForEachWithIndex lt T gt  this IEnumerable lt T gt  enumerable  Action lt T  int gt  handler                int idx   0          foreach  T item in enumerable              handler item  idx              public class Example       public static void Main                 string   values   new      foo    bar    baz              values ForEachWithIndex  item  idx    gt  Console WriteLine   0    1    idx  item

User · Answer

I just had this problem  but thinking around the problem in my case gave the best solution  unrelated to the expected solution   It could be quite a common case  basically  I m reading from one source list and creating objects based on them in a destination list  however  I have to check whether the source items are valid first and want to return the row of any error   At first-glance  I want to get the index into the enumerator of the object at the Current property  however  as I am copying these elements  I implicitly know the current index anyway from the current destination   Obviously it depends on your destination object  but for me it was a List  and most likely it will implement ICollection   i e   var destinationList   new List lt someObject gt     foreach  var item in itemList      var stringArray   item Split new char                 StringSplitOptions RemoveEmptyEntries      if  stringArray Length    2            use the destinationList Count property to give us the index into the stringArray list     throw new Exception  Item at row      destinationList Count   1      has a problem           else         destinationList Add new someObject     Prop1   stringArray 0   Prop2   stringArray 1             Not always applicable  but often enough to be worth mentioning  I think   Anyway  the point being that sometimes there is a non-obvious solution already in the logic you have

User · Answer

Here is another solution to this problem  with a focus on keeping the syntax as close to a standard foreach as possible    This sort of construct is useful if you are wanting to make your views look nice and clean in MVC  For example instead of writing this the usual way  which is hard to format nicely      lt  int i 0   foreach  var review in Model ReviewsList      gt       lt div id  review  lt   i  gt   gt           lt h3 gt  lt   review Title  gt  lt  h3 gt                             lt  div gt       lt  i         gt    You could instead write this     lt  foreach  var review in Model ReviewsList WithIndex        gt       lt div id  review  lt   LoopHelper Index    gt   gt           lt h3 gt  lt   review Title  gt  lt  h3 gt                             lt  div gt    lt      gt    I ve written some helper methods to enable this   public static class LoopHelper       public static int Index             return  int HttpContext Current Items  LoopHelper Index                    public static class LoopHelperExtensions       public static IEnumerable lt T gt  WithIndex lt T gt  this IEnumerable lt T gt  that            return new EnumerableWithIndex lt T gt  that              public class EnumerableWithIndex lt T gt    IEnumerable lt T gt            public IEnumerable lt T gt  Enumerable           public EnumerableWithIndex IEnumerable lt T gt  enumerable                Enumerable   enumerable                     public IEnumerator lt T gt  GetEnumerator                 for  int i   0  i  lt  Enumerable Count    i                      HttpContext Current Items  LoopHelper Index     i                  yield return Enumerable ElementAt i                                    IEnumerator IEnumerable GetEnumerator                 return GetEnumerator                      In a non-web environment you could use a static instead of HttpContext Current Items   This is essentially a global variable  and so you cannot have more than one WithIndex loop nested  but that is not a major problem in this use case

User · Answer

Why foreach     The simplest way is using for instead of foreach if you are using List   for  int i   0   i  lt  myList Count   i             Do something        Or if you want use foreach   foreach  string m in myList            Do something        You can use this to know the index of each loop   myList indexOf m

User · Answer

You could wrap the original enumerator with another that does contain the index information   foreach  var item in ForEachHelper WithIndex collection         Console Write  Index     item Index       Console Write   Value      item Value       Console Write   IsLast     item IsLast       Console WriteLine        Here is the code for the ForEachHelper class   public static class ForEachHelper       public sealed class Item lt T gt                public int Index   get  set            public T Value   get  set            public bool IsLast   get  set               public static IEnumerable lt Item lt T gt  gt  WithIndex lt T gt  IEnumerable lt T gt  enumerable                Item lt T gt  item   null          foreach  T value in enumerable                        Item lt T gt  next   new Item lt T gt                 next Index   0              next Value   value              next IsLast   false              if  item    null                                next Index   item Index   1                  yield return item                            item   next                    if  item    null                        item IsLast   true              yield return item

User · Answer

Using  FlySwat s answer  I came up with this solution     var list   new List lt int gt    1  2  3  4  5  6       Your sample collection  var listEnumerator   list GetEnumerator       Get enumerator  for  var i   0  listEnumerator MoveNext      true  i        int currentItem   listEnumerator Current     Get current item      Console WriteLine  At index  0   item is  1    i  currentItem      Do as you wish with i and  currentItem     You get the enumerator using GetEnumerator and then you loop using a for loop  However  the trick is to make the loop s condition listEnumerator MoveNext      true   Since the MoveNext method of an enumerator returns true if there is a next element and it can be accessed  making that the loop condition makes the loop stop when we run out of elements to iterate over

User · Answer

Finally C 7 has a decent syntax for getting an index inside of a foreach loop  i  e  tuples    foreach  var  item  index  in collection WithIndex          Debug WriteLine    index    item         A little extension method would be needed   public static IEnumerable lt  T item  int index  gt  WithIndex lt T gt  this IEnumerable lt T gt  self              gt  self Select  item  index    gt   item  index

User · Answer

C  7 finally gives us an elegant way to do this   static class Extensions       public static IEnumerable lt  int  T  gt  Enumerate lt T gt           this IEnumerable lt T gt  input          int start   0                     int i   start          foreach  var t in input                        yield return  i    t                      class Program       static void Main string   args                var s   new string                          Alpha                Bravo                Charlie                Delta                      foreach  var  i  t  in s Enumerate                          Console WriteLine    i    t

[c#] How do you get the index of the current iteration of a foreach loop?

Examples related to c#

Examples related to foreach