C# Arrays: Store Values and Traverse Every Shape Safely

What you will understand

• Create fixed-size arrays and replace individual elements.
• Explain default element values without treating them as validated data.
• Check zero-based positions and distinguish empty from null.
• Compare shared array references with copied integer elements.
• Calculate a guarded fractional average and maximum.
• Use GetLength for rectangular dimensions and Length for total cells.
• Traverse jagged rows using each current row’s length.
• Handle empty or absent rows through an explicit policy.

An array has one element type and a fixed instance size

An array groups ordered elements under one name. int[] scores means each element is an int. The initializer supplies the starting values and determines this array’s length. You have already traversed arrays; now distinguish the array object, its element values and its index positions.

An array instance has a fixed length after creation, but its elements can be replaced. Assigning scores[0] changes one value without adding or removing a slot. A variable can later refer to a different array, which is different from growing the existing instance. Resizable collection types belong to later study.

Use the earlier loops and numeric-type lessons as prerequisites. Every example is a complete Program.cs. Two examples intentionally fail at runtime to expose invalid boundaries. The lab summarizes a small score set and defines what happens when it has no elements.

using System;

int[] scores = { 60, 75, 90 };
Console.WriteLine($"Count: {scores.Length}");
Console.WriteLine($"First before: {scores[0]}");
scores[0] = 65;
Console.WriteLine($"First after: {scores[0]}");

Select Run code to compile and execute this program.

Count: 3
First before: 60
First after: 65

using System;

int[] counts = new int[2];
bool[] flags = new bool[1];
string?[] names = new string?[1];
Console.WriteLine($"Count slot: {counts[0]}");
Console.WriteLine($"Flag slot: {flags[0]}");
Console.WriteLine($"Name is null: {names[0] is null}");

Select Run code to compile and execute this program.

Count slot: 0
Flag slot: False
Name is null: True

Treat empty and absent arrays as different states

For an array of length n, valid indexes run from zero through n minus one. Length itself is outside the array. If a position comes from input or another calculation, check both position >= 0 and position < Length before accessing it.

An empty array is present and has zero elements. It is safe to traverse, but it has no first element or highest value to read. A null array is absent; reading Length on it would fail. Choose a presence policy before an empty check when the whole reference may be null.

Allocated slots receive default values, not validated application records. In particular, new string slots initially contain null references even if non-nullable annotations express a stronger intended contract. Initialize actual values or model missing data explicitly; compiler annotations do not populate storage.

using System;

int[] scores = { 60, 75 };
int position = 2;
if (position < 0 || position >= scores.Length)
{
    Console.WriteLine("Position is outside the array.");
    return;
}
Console.WriteLine(scores[position]);

Select Run code to compile and execute this program.

Position is outside the array.

using System;

int[] scores = { 60, 75 };
Console.WriteLine($"Count: {scores.Length}");
Console.WriteLine(scores[scores.Length]);

Select Run code to compile and execute this program.

Count: 2
Then execution fails with IndexOutOfRangeException.

Assignment shares an array; a copy needs separate storage

Arrays are reference types. When alias = original is assigned, both variables identify the same array instance. Mutating an element through one name is visible through the other. This is different from copying the value of an int element into its own int variable.

To preserve independent element storage, allocate another array and copy the elements. Array.Copy is a library helper for that work. With int elements, changing one copied slot does not affect the original slot.

Copying reference-type elements still copies references. A copied array of mutable objects would not automatically duplicate each object. The int example demonstrates independent integer slots without claiming a recursive deep-copy operation for arbitrary data.

using System;

int[] original = { 10, 20 };
int[] alias = original;
alias[0] = 99;
Console.WriteLine($"Original first: {original[0]}");
Console.WriteLine($"Alias first: {alias[0]}");

Select Run code to compile and execute this program.

Original first: 99
Alias first: 99

using System;

int[] original = { 10, 20 };
int[] copy = new int[original.Length];
Array.Copy(original, copy, original.Length);
copy[0] = 99;
Console.WriteLine($"Original first: {original[0]}");
Console.WriteLine($"Copy first: {copy[0]}");

Select Run code to compile and execute this program.

Original first: 10
Copy first: 99

Handle the no-data case before calculating a summary

A sum can start at zero even when there are no elements, but an average needs a positive count and a maximum needs a defined policy for no data. Guard the empty source before dividing or reading the first element to initialize a maximum.

Convert before dividing when a fractional average is intended. total / Length with two int operands performs integer division before any double assignment. Formatting with F1 cannot reconstruct the discarded fraction.

State the numeric assumptions. The examples use small valid scores and an int sum that fits. A larger source or unconstrained numeric values may need a wider accumulator, validation or explicit overflow handling. The array structure alone does not enforce score rules.

using System;

int[] scores = { 60, 75, 90 };
if (scores.Length == 0)
{
    Console.WriteLine("No scores to summarize.");
    return;
}
int total = 0;
foreach (int score in scores)
{
    total += score;
}
double average = (double)total / scores.Length;
Console.WriteLine($"Total: {total}");
Console.WriteLine($"Average: {average:F1}");

Select Run code to compile and execute this program.

Total: 225
Average: 75.0

A rectangular grid is one array with several dimensions

int[,] declares a two-dimensional rectangular array. You may interpret its first index as a row and its second as a column. Access a cell with grid[row, column], using one bracket pair containing both indexes.

GetLength(0) returns the size of the first dimension and GetLength(1) returns the second. Length returns the total number of cells. A two-row, three-column array has six cells, but six is not a valid row or column bound.

Use a separate bound for each nested loop. Reset a row total inside the outer body so each row gets its own result. A rectangular grid can have a zero-length dimension; do not assume a nonzero total or an existing first cell without checking the shape.

using System;

int[,] scores = { { 60, 70, 80 }, { 90, 100, 50 } };
Console.WriteLine($"Rows: {scores.GetLength(0)}");
Console.WriteLine($"Columns: {scores.GetLength(1)}");
Console.WriteLine($"Total elements: {scores.Length}");
Console.WriteLine($"Row 1, column 2: {scores[1, 2]}");

Select Run code to compile and execute this program.

Rows: 2
Columns: 3
Total elements: 6
Row 1, column 2: 50

using System;

int[,] scores = { { 60, 70, 80 }, { 90, 100, 50 } };
for (int row = 0; row < scores.GetLength(0); row++)
{
    int total = 0;
    for (int column = 0; column < scores.GetLength(1); column++)
    {
        total += scores[row, column];
    }
    Console.WriteLine($"Row {row + 1} total: {total}");
}

Select Run code to compile and execute this program.

Row 1 total: 210
Row 2 total: 240

A jagged structure is an array of separate arrays

int[][] is an outer array containing inner int arrays. Access a value with groups[row][column]. Each row is an independent array and may have a different length, including zero. The outer Length counts rows rather than scores.

Use the current row’s Length for its inner traversal. The first row’s length is not a promise about other rows. An empty first row must not hide later rows, and a long first row must not force access beyond a shorter later row.

Creating only the outer array leaves its row references null. Initialize each required row or handle a missing-row state deliberately before reading its Length. Empty and missing rows may mean different things, so do not silently substitute one for the other without a stated policy.

using System;

int[][] groups = { new int[] { 60, 80 }, Array.Empty<int>(), new int[] { 90 } };
Console.WriteLine($"Rows: {groups.Length}");
for (int row = 0; row < groups.Length; row++)
{
    Console.WriteLine($"Row {row + 1} entries: {groups[row].Length}");
}

Select Run code to compile and execute this program.

Rows: 3
Row 1 entries: 2
Row 2 entries: 0
Row 3 entries: 1

using System;

int[][] groups = new int[2][];
Console.WriteLine($"Outer rows: {groups.Length}");
Console.WriteLine($"First row absent: {groups[0] is null}");
groups[0] = new int[] { 60, 80 };
Console.WriteLine($"First row now has: {groups[0].Length}");

Select Run code to compile and execute this program.

Outer rows: 2
First row absent: True
First row now has: 2

Choose the shape from the meaning of the data

Use a single-dimensional array for one ordered sequence. A rectangular array is useful when every row shares a fixed set of columns, such as the same exercises across several sessions. A jagged array suits rows whose sizes legitimately differ, such as different numbers of readings per session.

Keep shape questions separate from domain questions. A valid index proves a slot exists, not that its score is acceptable. A present row can still be empty, and a copied array may still share referenced objects. Explain exactly what each check establishes.

Test an empty source, one item, several items, an empty row and rows of unequal lengths. For summaries, verify a fractional average and a correct highest value. For nested traversals, check every dimension independently instead of assuming the example’s first row describes the whole source.

Guided repair: traverse the current row

The second row is shorter than the first, so the program prints three valid scores and then fails. Repair the inner bound to describe the row currently being read, without assuming a uniform shape.

using System;

int[][] groups = { new int[] { 60, 80 }, new int[] { 90 } };
for (int row = 0; row < groups.Length; row++)
{
    for (int column = 0; column < groups[0].Length; column++)
    {
        Console.WriteLine(groups[row][column]);
    }
}

Select Run code to compile and execute this program.

60
80
90
Then execution fails with IndexOutOfRangeException.

Repair checkpoints

1. Use groups[row].Length for the current inner bound.
2. Keep the original source order and print 60, 80 and 90 once each.
3. With an empty first row and a later nonempty row, still visit the later scores.
4. An empty outer array produces no output.
5. The repair assumes present rows; explain why a null row would require a separate policy.

using System;

int[][] groups = { new int[] { 60, 80 }, new int[] { 90 } };
for (int row = 0; row < groups.Length; row++)
{
    for (int column = 0; column < groups[row].Length; column++)
    {
        Console.WriteLine(groups[row][column]);
    }
}

Select Run code to compile and execute this program.

60
80
90

Independent lab: a score summary with an empty-input policy

Summarize a small fixed score array with a count, fractional average and highest value. Define an explicit empty-source response and preserve the original values.

Acceptance checklist

• Use scores 70, 81 and 90 for the reference run.
• Check Length before reading a first element or dividing.
• For an empty source, print No scores to summarize. and return.
• Initialize highest from a real element after the guard.
• Traverse the values once to calculate the sum and maximum.
• Convert before division and print the average with one fractional digit.
• Print Count: 3, Average: 80.3 and Highest: 90 for the reference input.
• Assume small scores in 0 through 100 and an int sum that fits; do not claim to validate arbitrary datasets.

using System;

int[] scores = { 70, 81, 90 };
int total = 0;
foreach (int score in scores)
{
    total += score;
}
double average = total / scores.Length;
int highest = 0;
Console.WriteLine($"Count: {scores.Length}");
Console.WriteLine($"Average: {average:F1}");
Console.WriteLine($"Highest: {highest}");

Select Run code to compile and execute this program.

Count: 3
Average: 80.0
Highest: 0

using System;

int[] scores = { 70, 81, 90 };
if (scores.Length == 0)
{
    Console.WriteLine("No scores to summarize.");
    return;
}
int total = 0;
int highest = scores[0];
foreach (int score in scores)
{
    total += score;
    if (score > highest)
    {
        highest = score;
    }
}
double average = (double)total / scores.Length;
Console.WriteLine($"Count: {scores.Length}");
Console.WriteLine($"Average: {average:F1}");
Console.WriteLine($"Highest: {highest}");

Select Run code to compile and execute this program.

Count: 3
Average: 80.3
Highest: 90

Changed-input checks

• An empty array prints only the no-data message.
• One score of 81 produces count 1, average 81.0 and highest 81.
• Scores 0 and 100 produce average 50.0 and highest 100.
• Three scores of 75 produce average and highest 75.
• Reorder the reference source: the summary should stay the same.

Recap: choose the array shape and its bounds

Check the whole reference, the number of elements and each row’s shape separately. Copying, validation and summary calculations answer different questions.

T[]

One ordered array of elements of type T.

new int[count]

Allocate fixed slots initialized to zero.

index < values.Length

Stay below the one-dimensional upper bound; also reject negative indexes.

alias = original

Share one array instance rather than copy its elements.

Array.Copy

Copy elements into separate storage; reference elements still share their referenced objects.

T[,] / GetLength

One rectangular multidimensional array with a length per dimension.

T[][] / row.Length

An array of row arrays, each with its own length and presence state.

empty guard

Handle the no-data case before first-element reads or division.

Frequently asked questions

Next step and references

Arrays have fixed instance sizes, zero-based positions and reference semantics. Check empty sources before calculating, use each rectangular dimension’s bound, and respect the separate shape and presence of jagged rows.

Next is C# Methods and Return Values. You will extract repeated work into named operations, distinguish performing an action from returning a result, and follow control between a caller and a method.

Official references

Original SovranCode explanations, examples and exercises. Technical details were checked against these references.

• Microsoft Learn: Arrays

Last updated: 27 October 2026.