What is the difference between multi-dimensional (rectangular) arrays and jagged arrays in C#? How are they laid out in memory, which is faster, and when would you flatten a grid into a single-dimensional array?

1. SZ arrays vs MD arrays in the CLR

The runtime distinguishes:

• SZ arrays (single-dimensional, zero-based): T[]. Dedicated IL instructions (newarr, ldelem, stelem, ldlen) and heavily optimised in the JIT.
• MD arrays (multi-dimensional or non-zero-based): T[,], T[,,], and also T[*] (single-dimensional with a non-zero lower bound). Accessed through runtime-provided Get, Set and Address methods on the array type.

An int[,] object stores, after the header and MethodTable, the total length, then for each dimension its length and lower bound, then the data. Each element access does: (i - lb0) unsigned-compared to len0, (j - lb1) compared to len1, then computes offset = (i - lb0) * len1 + (j - lb1).

The JIT has improved MD array access significantly (since .NET 7 it inlines the accessors and can remove some checks), but SZ arrays still get more optimisations, especially loop cloning and vectorisation.

2. Bounds-check elimination with jagged rows

for (int i = 0; i < jagged.Length; i++)
{
    int[] row = jagged[i];               // one bounds check for the outer array
    for (int j = 0; j < row.Length; j++) // pattern recognised: no bounds check on row[j]
        sum += row[j];
}

The inner loop is a plain SZ array loop: the JIT removes the bounds check and can vectorise if you use span APIs. The equivalent grid[i, j] loop keeps checks unless the JIT can prove both ranges.

3. Cache behaviour

CPUs fetch memory in 64-byte cache lines. Row-major traversal of a contiguous grid uses every byte of each line fetched (16 ints per line). With jagged arrays, each row is contiguous, but moving to the next row may jump to a distant address — usually fine for long rows, costly for many short rows. For column-wise access:

for j in cols: for i in rows: grid[i, j]     // stride = cols * 4 bytes -> cache miss per access on big grids

Transposing the data or the algorithm (process rows, or store column-major when columns are hot) fixes this. Hardware prefetchers detect constant strides but not huge ones.

4. Allocation and GC

• A jagged array of 10,000 rows = 10,001 objects. GC marking must visit each; rows can be fragmented across generations.
• A rectangular or flattened grid is one object. If it exceeds ~85 KB it goes to the LOH — collected only in Gen2 and not compacted by default — so allocate it once and reuse (ArrayPool<T>.Shared.Rent(rows * cols) or a long-lived instance).
• GC.AllocateUninitializedArray<T>(n) skips zeroing for large buffers you'll overwrite immediately.

5. Interop and libraries

Flattened buffers match how native libraries and tensors think: BLAS, ONNX Runtime, ML.NET, image libraries (ImageSharp exposes rows as spans), and .NET 9/10's System.Numerics.Tensors (Tensor<T>, TensorSpan<T>) all use contiguous memory with shape and strides. MemoryMarshal.CreateSpan(ref grid[0, 0], grid.Length) can view a rectangular array as a flat span when you need to bridge.

6. Choosing

Try it yourself

1. Benchmark summing a 2,000 × 2,000 grid as int[,], int[][] and flattened int[], row-major and column-major.
2. Count objects with dotnet-gcdump for a 10,000-row jagged array vs a rectangular one.
3. Write the Grid<T> class above and use Row(r).Fill(0) and TensorPrimitives.Sum(Row(r)).
4. Print grid.Rank, GetLength(0), GetLowerBound(0) for a rectangular array.

using System.Numerics.Tensors;

namespace Arrays;

// A small grid type over a flattened array
public sealed class Grid<T>(int rows, int cols)
{
    private readonly T[] _cells = new T[rows * cols];
    public int Rows { get; } = rows;
    public int Cols { get; } = cols;

    public ref T this[int row, int col] => ref _cells[row * Cols + col];
    public Span<T> Row(int row) => _cells.AsSpan(row * Cols, Cols);
}

public static class MultiDimensional
{
    public static void Main()
    {
        // Rectangular
        int[,] seats = new int[3, 4];
        seats[1, 2] = 7;
        Console.WriteLine($"{seats.Rank} {seats.GetLength(0)}x{seats.GetLength(1)} total {seats.Length}");
        Console.WriteLine(seats.Cast<int>().Sum());       // LINQ needs Cast<int>()

        // Jagged: ragged rows (Pascal's triangle)
        int[][] pascal = new int[5][];
        for (int r = 0; r < pascal.Length; r++)
        {
            var row = pascal[r] = new int[r + 1];
            row[0] = row[r] = 1;
            for (int c = 1; c < r; c++) row[c] = pascal[r - 1][c - 1] + pascal[r - 1][c];
        }
        Console.WriteLine(string.Join(" ", pascal[4]));  // 1 4 6 4 1

        // Flattened grid with span rows and SIMD sums
        var distances = new Grid<float>(3, 3);
        distances[0, 1] = 12.5f;
        distances[1, 2] = 4f;
        for (int r = 0; r < distances.Rows; r++)
            Console.WriteLine($"Row {r} total {TensorPrimitives.Sum<float>(distances.Row(r))}");
    }

    // Row-first traversal with the row hoisted out of the inner loop
    public static long SumJagged(int[][] data)
    {
        long total = 0;
        foreach (var row in data)
            foreach (var value in row)
                total += value;
        return total;
    }
}