Get the Current Index in a foreach Loop in C#

By the end of this page, you will understand why foreach in C# does not directly expose an index, how to track an index manually, when to switch to a for loop, and which real-world patterns developers use when they need both an item and its position.

foreach in C# is designed to iterate over items in a sequence, not over numeric positions.

When you write:

foreach (var item in collection)
{
    // ...
}

you are saying:

• "Give me each item in this collection"
• not "Give me item number 0, then 1, then 2..."

That design makes foreach simple and readable. It works with many kinds of collections, including ones that may not even support indexing efficiently.

Why there is no built-in index in foreach

Not every enumerable sequence has a natural index.

For example:

• List<T> has indexes
• arrays have indexes
• a streamed sequence from LINQ may not have a meaningful index you can jump to
• custom IEnumerable<T> types may only know how to return the next item

Because of that, the foreach statement focuses on values, not positions.

So how do you get the index?

In practice, you have three common options:

1. Track the index manually
2. Use a for loop if the collection supports indexing

Think of foreach like reading items from a conveyor belt.

• With foreach, you only receive the next item.
• With a for loop, you have a numbered shelf, and you can say "give me item at position 3".

So if your task is mainly "process every item," foreach is a great fit. If your task is "process item number i," then for is often the better tool.

Manual indexing inside foreach is like keeping your own counter while watching the conveyor belt pass by.

1. Manual index with foreach

int index = 0;
foreach (var item in collection)
{
    Console.WriteLine($"Index: {index}, Value: {item}");
    index++;
}

This is the simplest way to keep track of position while using foreach.

2. Use for with an indexable collection

If the collection is an array or List<T>, a for loop is often cleaner:

for (int i = 0; i < collection.Count; i++)
{
    Console.WriteLine($"Index: {i}, Value: {collection[i]}");
}

Use this when:

• you need the index often
• you need to access neighboring items
• you need to modify items by position

3. LINQ with index

C# also supports getting indexes through LINQ:

using System.Linq;

 ( pair  collection.Select((item, index) =>  { item, index }))
{
    Console.WriteLine();
}

Consider this code:

string[] names = { "Ana", "Ben", "Cara" };

int index = 0;
foreach (var name in names)
{
    Console.WriteLine($"{index}: {name}");
    index++;
}

Step-by-step

1. names is created with three values:

   • "Ana"
   • "Ben"
   • "Cara"

2. index starts at 0.

3. First loop iteration:

   • name becomes "Ana"
   • output is 0: Ana
   • index++ changes index from 0 to

Numbered UI output

int i = 1;
foreach (var task in tasks)
{
    Console.WriteLine($"{i}. {task.Title}");
    i++;
}

Useful for menus, reports, and lists shown to users.

CSV or formatted output

You may need special formatting based on position, such as adding commas between items but not after the last one.

for (int i = 0; i < tags.Count; i++)
{
    Console.Write(tags[i]);
    if (i < tags.Count - 1)
    {
        Console.Write(", ");
    }
}

Data import and validation

When validating rows from a file, an index helps identify the row number.

int rowNumber = 1;
foreach (var row in rows)
{
    if (string.IsNullOrWhiteSpace(row.Email))
    {
        Console.WriteLine($"Row {rowNumber}: Email is required.");
    }
    rowNumber++;
}

Comparing with adjacent items

If you need previous or next values, a loop is usually better.

In real projects, developers usually choose between foreach and for based on intent.

Common patterns

1. Plain foreach for readability

foreach (var user in users)
{
    SendWelcomeEmail(user);
}

This is the cleanest choice when position does not matter.

2. Manual counter when index is only extra information

int index = 0;
foreach (var file in files)
{
    logger.LogInformation("Processing file {Index}: {Name}", index, file.Name);
    ProcessFile(file);
    index++;
}

This works well for logging, display numbering, or diagnostics.

3. for when position drives the logic

for (int i = 0; i < items.Count; i++)
{
    if (i == 0)
    {
        continue;
    }

    items[i].PreviousId = items[i - ].Id;
}

1. Forgetting to increment the counter

Broken code:

int i = 0;
foreach (var item in collection)
{
    Console.WriteLine(i);
}

Problem:

• i always stays 0

Fix:

int i = 0;
foreach (var item in collection)
{
    Console.WriteLine(i);
    i++;
}

2. Incrementing in the wrong place

Broken code:

int i = 0;
foreach (var item in collection)
{
    i++;
    Console.WriteLine(i);
}

Problem:

• output starts at 1, not 0

Fix depends on what you want:

• increment after using i for zero-based indexes

Quick reference

foreach has no built-in index

foreach (var item in collection)
{
    // item only
}

Manual index in foreach

int index = 0;
foreach (var item in collection)
{
    // use item and index
    index++;
}

for loop with index

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

LINQ index projection

var withIndexes = collection.Select((item, index) => new { item, index });

Rules of thumb

• Use foreach when you only need values
• Use for when index is part of the logic

Is there an index variable built into C# foreach?

No. The foreach statement gives you the current item, not its index.

What is the simplest way to get an index in foreach?

Use a separate counter variable:

int index = 0;
foreach (var item in collection)
{
    index++;
}

Should I use for instead of foreach when I need the index?

Usually yes, especially if the collection supports indexing and your logic depends on position.

Can I get the index with LINQ in C#?

Yes. Select has an overload that provides both the item and the index.

Is foreach slower than for in C#?

Performance depends on the collection type and the scenario. In most beginner and everyday code, readability matters more than tiny differences.

Can I use foreach with collections that do not have indexes?

Yes. That is one of its main advantages. foreach works with any enumerable sequence.

• for loop — useful when you need direct control over the index.
• IEnumerable<T> — explains why foreach works on many sequence types.
• List<T> — a common collection type that supports indexing.
• arrays in C# — arrays are index-based and often used with for.
• LINQ Select — provides an overload that includes the item index.
• loop control statements — related because break and continue are often used inside loops.
• off-by-one errors — important when working with manual indexes.
• collection modification during iteration — relevant because changing a collection inside foreach can cause errors.