How to loop with an index in C#

List<string> fruits = ["apple", "banana", "cherry"];

// .NET 9+: Index() pairs every element with its position.
foreach (var (index, fruit) in fruits.Index())
{
    Console.WriteLine($"{index}: {fruit}");
}

// Number from 1: print i + 1, the index itself stays 0-based.
foreach (var (i, fruit) in fruits.Index())
{
    Console.WriteLine($"{i + 1}. {fruit}");
}

// Any IEnumerable<T> works, not just lists: here, the chars of a string.
foreach (var (i, ch) in "C# 14".Index())
{
    if (char.IsDigit(ch)) Console.WriteLine($"digit '{ch}' at {i}");
}

// break and continue behave as usual.
foreach (var (i, fruit) in fruits.Index())
{
    if (fruit.StartsWith('b'))
    {
        Console.WriteLine($"first b-fruit at index {i}");
        break;
    }
}

// Order matters: Index() before Where keeps the original positions.
int[] scores = [72, 95, 41, 88];
foreach (var (i, s) in scores.Index().Where(p => p.Item >= 80))
{
    Console.WriteLine($"original index {i}: {s}");
}
foreach (var (i, s) in scores.Where(s => s >= 80).Index())
{
    Console.WriteLine($"filtered index {i}: {s}");
}

string[] langs = ["C#", "F#", "VB", "C++"];

// Before .NET 9: this Select overload passes the index as a second argument.
foreach (var (lang, i) in langs.Select((lang, i) => (lang, i)))
{
    Console.WriteLine($"{i}: {lang}");
}

// The same overload can build the result directly, no loop needed.
var numbered = langs.Select((lang, i) => $"{i + 1}) {lang}");
Console.WriteLine(string.Join("  ", numbered));

// Where has an index overload too: keep the elements at even positions.
var evenPositions = langs.Where((lang, i) => i % 2 == 0);
Console.WriteLine(string.Join(", ", evenPositions));

// Code from before C# 7 tuples uses an anonymous type instead.
foreach (var x in langs.Select((value, index) => new { value, index }))
{
    Console.WriteLine($"{x.index} -> {x.value}");
}

int[] temps = [18, 21, 25, 19, 23];

// The classic loop: arrays use Length, List<T> uses Count.
for (int i = 0; i < temps.Length; i++)
{
    Console.WriteLine($"day {i}: {temps[i]}");
}

// With the index you can write back into the array.
for (int i = 0; i < temps.Length; i++)
{
    temps[i] += 1;
}
Console.WriteLine(string.Join(", ", temps));

// Backwards, and in steps of 2.
for (int i = temps.Length - 1; i >= 0; i--)
{
    Console.Write($"{temps[i]} ");
}
Console.WriteLine();
for (int i = 0; i < temps.Length; i += 2)
{
    Console.Write($"[{i}]={temps[i]} ");
}
Console.WriteLine();

// Compare each element with the one before it.
for (int i = 1; i < temps.Length; i++)
{
    Console.WriteLine($"day {i}: {temps[i] - temps[i - 1]:+0;-0;0}");
}

// Removing from a List<T>: go backwards so the indexes ahead don't shift.
List<int> nums = [1, 2, 3, 4, 5, 6];
for (int i = nums.Count - 1; i >= 0; i--)
{
    if (nums[i] % 2 == 0) nums.RemoveAt(i);
}
Console.WriteLine(string.Join(", ", nums));

string[] words = ["red", "green", "red", "blue"];

// A counter declared outside the loop works on any version of C#.
int index = 0;
foreach (var word in words)
{
    Console.WriteLine($"{index}: {word}");
    index++;
}

// Trap 1: continue jumps over the increment, so the count drifts.
int i = 0;
foreach (var word in words)
{
    if (word == "green") continue; // i++ never runs for "green"
    Console.WriteLine($"drifted {i}: {word}");
    i++;
}

// Fix: increment at the top, before anything can skip it.
int n = -1;
foreach (var word in words)
{
    n++;
    if (word == "green") continue;
    Console.WriteLine($"correct {n}: {word}");
}

// Trap 2: IndexOf finds the FIRST match, so duplicates get the wrong index.
foreach (var word in words)
{
    Console.WriteLine($"IndexOf({word}) = {Array.IndexOf(words, word)}");
}

string[] names = ["alice", "bob", "carol"];
int[] scores = [91, 78, 85];
char[] grades = ['A', 'C', 'B'];

// Zip pairs two sequences by position, no index variable needed.
foreach (var (name, score) in names.Zip(scores))
{
    Console.WriteLine($"{name}: {score}");
}

// .NET 6+: Zip takes a third sequence.
foreach (var (name, score, grade) in names.Zip(scores, grades))
{
    Console.WriteLine($"{name} {score} {grade}");
}

// Need the position as well? Chain Index() (.NET 9+) and nest the pattern.
foreach (var (i, (name, _)) in names.Zip(scores).Index())
{
    Console.WriteLine($"#{i + 1} {name}");
}

// Zip stops at the shorter sequence without telling you.
int[] partial = [60, 70];
Console.WriteLine($"pairs: {names.Zip(partial).Count()}");

// A for loop with an explicit bound does the same, and can handle the rest.
int common = Math.Min(names.Length, partial.Length);
for (int i = 0; i < names.Length; i++)
{
    string score = i < common ? partial[i].ToString() : "missing";
    Console.WriteLine($"{i}: {names[i]} {score}");
}