Arrays

An array holds a fixed number of values of one type, laid out next to each other in memory. You decide the size when you create it, and that size never changes.

Two consequences follow from "next to each other". Reading any position is fast and costs the same wherever it is, because the machine can calculate exactly where to look. And growing the array is impossible — there may well be something else in memory immediately after it. Adding an item means creating a bigger array and copying everything across.

// Twelve monthly sales figures, all starting at zero.
decimal[] monthlySales = new decimal[12];

monthlySales[0] = 145_000m;      // January — positions start at 0
monthlySales[11] = 210_000m;     // December — the last position is Length - 1

// Or state the values up front and let the compiler count them.
string[] regions = { "North", "South", "East", "West" };

Console.WriteLine(regions.Length);      // 4
Console.WriteLine(regions[2]);          // East

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

foreach (string region in regions)
{
    Console.WriteLine(region);
}

• decimal[] means "an array of decimal". new decimal[12] reserves twelve slots.
• A new array is not empty, it is filled with the default for its type: 0 for numbers, false for bool, null for reference types such as string.
• Positions are numbered from 0, so a twelve-item array has positions 0 to 11. Length is 12.
• { "North", "South", ... } is an array initialiser. The size comes from how many values you wrote.
• Use a for loop when you need the position number, and foreach when you only need the values. foreach is harder to get wrong.

// Rectangular: 4 regions by 12 months, every row the same width.
decimal[,] salesByRegionAndMonth = new decimal[4, 12];

salesByRegionAndMonth[0, 0] = 145_000m;    // North, January
salesByRegionAndMonth[3, 11] = 98_000m;    // West, December

Console.WriteLine(salesByRegionAndMonth.GetLength(0));   // 4  — rows
Console.WriteLine(salesByRegionAndMonth.GetLength(1));   // 12 — columns

for (int region = 0; region < salesByRegionAndMonth.GetLength(0); region++)
{
    decimal total = 0m;

    for (int month = 0; month < salesByRegionAndMonth.GetLength(1); month++)
    {
        total += salesByRegionAndMonth[region, month];
    }

    Console.WriteLine($"Region {region} total: {total:N2}");
}

// Jagged: an array of arrays, so rows can differ in length.
string[][] teamsByOffice = new string[3][];

teamsByOffice[0] = new string[] { "Asha", "Ravi" };
teamsByOffice[1] = new string[] { "Meera" };
teamsByOffice[2] = new string[] { "Karan", "Divya", "Sanjay" };

Console.WriteLine(teamsByOffice[2][1]);          // Divya
Console.WriteLine(teamsByOffice[2].Length);      // 3

• decimal[4, 12] with one set of brackets and a comma is a single rectangular block. Every row has exactly twelve columns.
• Length on a rectangular array gives the total number of cells, which is 48 here. Use GetLength(0) and GetLength(1) for the row and column counts.
• string[][] with two sets of brackets is an array whose items are themselves arrays. Each inner array is created separately and can be a different length.
• A jagged array starts as an array of nulls. teamsByOffice[0] is null until you assign an inner array to it, which is a frequent source of confusion.
• Indexing differs: [row, column] for rectangular, [row][column] for jagged.

That copying problem is not hypothetical. Suppose you are reading orders from a file and you do not know how many there are. With an array you would have to guess a size, then detect when it filled up, allocate a bigger one, copy everything over, and carry on — and get all of that right while also parsing the file.

That work is worth doing exactly once, by someone else, in a reusable type. That type is List, and it is next.