Using C# Nested For Loops Effectively

A c# nested for loop places one for loop inside another, causing the inner loop to run completely for each iteration of the outer loop. This is the most direct way to iterate over two-dimensional data structures, such as matrices, grids, or combinations of elements from two collections. The pattern is simple, but its runtime cost and readability deserve careful attention.

Basic Syntax and Execution Order

The classic nested for loop in C# looks like this:

for (int i = 0; i < rows; i++)
{
    for (int j = 0; j < columns; j++)
    {
        Console.WriteLine($"Cell [{i},{j}]");
    }
}

For each value of i, the inner loop runs from j = 0 to j < columns. If rows is 3 and columns is 4, the body executes 12 times. The order is row-major: the inner loop completes for a fixed row before moving to the next row. This matches how most developers think about grid traversal.

When the inner loop does not depend on the outer loop variable, the total number of iterations is simply rows * columns. If the inner loop's bound depends on i, as in a triangular iteration, the count becomes rows * (rows + 1) / 2. Understanding this count is essential for estimating runtime.

Iterating Over Multidimensional Arrays

Nested loops are the natural fit for rectangular arrays declared with [,]:

int[,] matrix = new int[3, 4];

for (int i = 0; i < matrix.GetLength(0); i++)
{
    for (int j = 0; j < matrix.GetLength(1); j++)
    {
        matrix[i, j] = i * j;
    }
}

Use GetLength(0) for the first dimension and GetLength(1) for the second. A common mistake is to use matrix.Length, which returns the total number of elements, not the size of a dimension. That would cause an IndexOutOfRangeException on the inner loop.

For jagged arrays (int[][]), the inner loop iterates over each sub-array, which may have different lengths:

int[][] jagged = new int[3][];
jagged[0] = new int[2];
jagged[1] = new int[5];
jagged[2] = new int[3];

for (int i = 0; i < jagged.Length; i++)
{
    for (int j = 0; j < jagged[i].Length; j++)
    {
        jagged[i][j] = i + j;
    }
}

Jagged arrays require the inner loop to read the current sub-array's length, which is fine but slightly less cache-friendly than a rectangular array because each row is a separate object.

Breaking Out of a Nested For Loop

A break statement inside the inner loop only exits that inner loop, not the outer one. To stop both loops, you need an explicit flag or a goto:

bool found = false;
for (int i = 0; i < rows && !found; i++)
{
    for (int j = 0; j < columns; j++)
    {
        if (data[i, j] == target)
        {
            found = true;
            break;
        }
    }
}

Adding !found to the outer loop condition is a clean way to stop iterating once the flag is set. Alternatively, goto can jump out of both loops directly:

for (int i = 0; i < rows; i++)
{
    for (int j = 0; j < columns; j++)
    {
        if (data[i, j] == target)
            goto Found;
    }
}

Found:
Console.WriteLine("Search complete");

goto is acceptable for breaking out of deeply nested loops, but many codebases prefer the flag approach for readability.

Runtime Cost and Complexity

A nested loop's time complexity is the product of the loop bounds. If both loops run n times, the body executes n² times. This quadratic growth means that doubling the input size quadruples the work. For large n, this can become the bottleneck.

The actual cost also depends on what happens inside the body. A simple assignment is cheap, but calling a method that performs I/O or allocates objects will dominate. Consider whether the inner loop can be replaced with a more efficient algorithm, such as sorting or using a hash set, rather than comparing every pair of elements.

Memory access patterns matter too. Iterating over a multidimensional array row by row is cache-friendly because the elements are contiguous in memory. Iterating column by column (with the inner loop over rows) jumps across rows, causing cache misses. If performance is critical, choose the iteration order that matches the memory layout.

When to Replace Nested Loops with LINQ

LINQ can make code more readable, but it does not automatically improve performance. For example, generating all pairs from two lists can be written with SelectMany:

var pairs = listA.SelectMany(a => listB, (a, b) => (a, b));

This produces the same Cartesian product as a nested loop. The runtime cost is similar because SelectMany still iterates through all combinations. However, LINQ introduces delegate invocation overhead, which may make it slower in tight loops. Use LINQ when readability and declarative intent matter more than raw speed.

A more meaningful replacement is when the nested loop is searching for a condition. Any or FirstOrDefault can short-circuit and stop early, but a hand-written loop can also break early. The advantage of LINQ is not speed but clarity.

For element-wise operations on two same-length arrays, Zip is a better fit than a nested loop:

int[] result = arrayA.Zip(arrayB, (a, b) => a + b).ToArray();

This iterates once, not in a nested fashion. If you find yourself writing a nested loop where the inner loop index does not depend on the outer loop, you may actually need a single loop over a flattened structure.

Avoiding Common Pitfalls

One frequent bug is reusing the same variable name for inner and outer loop counters. This is legal in C# only if the scopes do not overlap, but it is confusing. Use distinct names like i and j consistently.

Another issue is modifying the collection being iterated. If you add or remove items inside a nested loop, you may get an InvalidOperationException or unexpected behavior. Collect the changes in a separate list and apply them after the loop.

Off-by-one errors are common when the loop bound is computed from a property that changes. For example, using list.Count inside the inner loop while removing items will cause the loop to skip elements. Store the original count before the loop if you must mutate the collection.

Parallelizing Nested Loops

When the outer loop iterations are independent, Parallel.For can speed up the work on multi-core machines:

Parallel.For(0, rows, i =>
{
    for (int j = 0; j < columns; j++)
    {
        ProcessCell(i, j);
    }
});

This parallelizes the outer loop, and each thread runs its own inner loop. The inner loop should not share mutable state without synchronization. Parallelization adds overhead, so it only helps when the body does enough work to outweigh thread management costs. For small matrices, a sequential loop is faster.

Be careful with Parallel.For when the inner loop writes to shared positions in an array. Each iteration writes to a distinct (i, j) cell, which is safe if the array is not resized and each cell is written by only one thread. If you need to accumulate results, use thread-local storage or a lock.

Choosing the Right Iteration Strategy

The decision to use a nested for loop depends on the data structure and the operation. For small, fixed-size grids, a nested loop is straightforward and maintainable. For large datasets, consider whether an alternative algorithm reduces the number of comparisons. For simple element-wise operations, Zip or a single loop over a flattened array may be more efficient.

When the inner loop's bound depends on the outer loop, the code often represents a combinatorial pattern. In those cases, a recursive approach or a different enumeration strategy might be clearer. The nested for loop is not inherently bad; it is the right tool when the iteration space is naturally two-dimensional and the operation is simple.