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
3. Use LINQ with index projection when appropriate

Why this matters in real programming

You often need an index for tasks like:

• showing row numbers in a UI
• building comma-separated output
• comparing neighboring items
• applying special logic to the first or last item
• mapping items into numbered results

Choosing the right pattern makes code easier to read and avoids unnecessary complexity.

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;

foreach (var pair in collection.Select((item, index) => new { item, index }))
{
    Console.WriteLine($"Index: {pair.index}, Value: {pair.item}");
}

This can be nice when you are already using LINQ, but it is usually more advanced than a simple for or manual counter.

Beginner recommendation

• Use foreach when you only need the item
• Use a manual counter if you occasionally need the index
• Use for when index-based access is central to the logic

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 1

4. Second loop iteration:

   • name becomes "Ben"
   • output is 1: Ben
   • index++ changes index from 1 to 2

5. Third loop iteration:

   • name becomes "Cara"
   • output is 2: Cara
   • index++ changes index from 2 to 3

6. The loop ends because there are no more items.

Final output

0: Ana
1: Ben
2: Cara

The important detail is that foreach itself does not manage a visible index for you. You created and updated the index manually.

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 for loop is usually better.

for (int i = 1; i < numbers.Count; i++)
{
    if (numbers[i] < numbers[i - 1])
    {
        Console.WriteLine("Sequence decreased.");
    }
}

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 - 1].Id;
}

This is common when code needs neighboring elements or direct assignment by index.

4. LINQ projection when transforming data

var numbered = items
    .Select((item, index) => new
    {
        Index = index,
        Name = item.Name
    })
    .ToList();

This is useful in APIs, view models, exports, and data transformation pipelines.

Practical rule

A lot of production code follows this idea:

• prefer foreach for simple iteration
• switch to for when index logic becomes important
• avoid forcing foreach to do index-heavy work if for reads better

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
• increment before using i for one-based numbering

3. Using foreach when for is simpler

Awkward code:

int i = 0;
foreach (var item in list)
{
    if (i > 0)
    {
        Console.WriteLine(list[i - 1]);
    }
    Console.WriteLine(item);
    i++;
}

Better:

for (int i = 0; i < list.Count; i++)
{
    if (i > 0)
    {
        Console.WriteLine(list[i - 1]);
    }
    Console.WriteLine(list[i]);
}

4. Assuming all collections support indexing

Broken idea:

foreach (var item in sequence)
{
    // trying to use sequence[0] may not even compile
}

Problem:

• many IEnumerable<T> sequences do not support []

Fix:

• use a manual counter
• materialize into a list if indexing is really needed
• or use for only when the type supports it

5. Modifying a collection during foreach

Broken code:

foreach (var item in list)
{
    list.Remove(item);
}

Problem:

• this usually throws an exception

Fix:

• use a for loop in reverse
• or build a new filtered collection

foreach vs for

foreach (var name in names)
{
    Console.WriteLine(name);
}

Best for item-focused processing.

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

Best for position-focused processing.

Manual counter vs LINQ index projection

Manual counter is usually easier for beginners:

int i = 0;
foreach (var item in items)
{
    Console.WriteLine($"{i}: {item}");
    i++;
}

LINQ is useful when producing a new sequence:

var result = items.Select((item, index) => $"{index}: {item}");

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
• Use a manual counter if you want to keep foreach
• Use LINQ indexing when transforming data

Common edge cases

• Start at 0 for zero-based indexing
• Start at 1 for user-facing numbering
• Do not modify a collection during foreach
• Not every enumerable supports collection[i]

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.

Why does foreach not expose the index directly?

Because many sequences are designed to be iterated one item at a time and may not have a natural or efficient numeric index.

• 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.