C# Array: Declare, Length, Sort, 2D and Jagged Arrays

An array holds a fixed number of elements of one type, stored side by side in memory. You choose the length when you create it, you read and write elements by a zero-based index, and the length never changes after that.

Declaring and initializing an array

The type of an array is the element type followed by []. There are several ways to create one:

using System;

class Program
{
    static void Main()
    {
        int[] scores = new int[4];                     // 4 elements, all 0
        string[] names = { "Ana", "Ben", "Chloe" };     // initializer
        double[] prices = new double[] { 2.5, 9.99 };   // explicit form
        var days = new[] { "Mon", "Tue", "Wed" };       // type inferred: string[]

        scores[0] = 90;
        scores[3] = 72;

        Console.WriteLine(string.Join(", ", scores));
        Console.WriteLine(names[1]);
        Console.WriteLine(prices.Length + " prices, " + days.Length + " days");
    }
}

Output:

90, 0, 0, 72
Ben
2 prices, 3 days

new int[4] fills every element with the default value of the type: 0 for numbers, false for bool, null for strings and other reference types. The short form { "Ana", "Ben" } only works in a declaration; when assigning to an existing variable you need names = new[] { "Dev", "Eli" };.

Length, indexing and the last element

Indexes run from 0 to Length - 1. Length is a property, so it has no parentheses (unlike LINQ's Count() method).

using System;

class Program
{
    static void Main()
    {
        int[] temps = { 18, 21, 25, 19, 16 };

        Console.WriteLine("Count: " + temps.Length);
        Console.WriteLine("First: " + temps[0]);
        Console.WriteLine("Last: " + temps[temps.Length - 1]);

        try
        {
            Console.WriteLine(temps[5]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }
    }
}

Output:

Count: 5
First: 18
Last: 16
Caught IndexOutOfRangeException

Reading or writing outside the bounds throws IndexOutOfRangeException at run time; the compiler does not catch it. The usual cause is a loop condition written as i <= arr.Length instead of i < arr.Length.

C# 8 and later add index-from-end and range syntax, which is shorter for the last element and for slices:

int last = temps[^1];        // 16
int[] middle = temps[1..4];  // { 21, 25, 19 }, a new array

Looping over an array

A for loop gives you the index; foreach gives you each element and is the clearer choice when you only read.

using System;

class Program
{
    static void Main()
    {
        decimal[] prices = { 4.50m, 12.00m, 3.25m };

        for (int i = 0; i < prices.Length; i++)
        {
            prices[i] = Math.Round(prices[i] * 1.10m, 2); // raise every price by 10%
        }

        decimal total = 0;
        foreach (decimal p in prices)
        {
            total += p;
        }

        Console.WriteLine(string.Join(" | ", prices));
        Console.WriteLine("Total: " + total);
    }
}

Output:

4.95 | 13.20 | 3.58
Total: 21.73

The foreach variable is read-only: p = 0; inside the loop is a compile error. To change elements, loop with an index.

Sorting, reversing and searching

The static Array class holds the helpers. Array.Sort sorts in place and returns nothing, so the original order is gone.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79 };

        Array.Sort(scores);
        Console.WriteLine("Ascending:  " + string.Join(", ", scores));

        Array.Reverse(scores);
        Console.WriteLine("Descending: " + string.Join(", ", scores));

        Console.WriteLine("Index of 60: " + Array.IndexOf(scores, 60));
        Console.WriteLine("Index of 99: " + Array.IndexOf(scores, 99));
        Console.WriteLine("Any above 90: " + Array.Exists(scores, s => s > 90));
        Console.WriteLine("First below 75: " + Array.Find(scores, s => s < 75));

        string[] names = { "chloe", "Ana", "ben" };
        Array.Sort(names, StringComparer.OrdinalIgnoreCase);
        Console.WriteLine(string.Join(", ", names));

        string[] fruits = { "kiwi", "banana", "fig" };
        Array.Sort(fruits, (a, b) => a.Length.CompareTo(b.Length)); // by length
        Console.WriteLine(string.Join(", ", fruits));
    }
}

Output:

Ascending:  60, 72, 79, 88, 95
Descending: 95, 88, 79, 72, 60
Index of 60: 4
Index of 99: -1
Any above 90: True
First below 75: 72
Ana, ben, chloe
fig, kiwi, banana

Array.IndexOf returns -1 when the value is missing. Array.Find returns the default value of the type (0 here) when nothing matches, which is ambiguous for numbers; use Array.FindIndex when that matters. A descending sort in one call is Array.Sort(scores, (a, b) => b.CompareTo(a)).

If you need the sorted result without touching the original, LINQ returns a new array: var sorted = scores.OrderBy(s => s).ToArray();. See LINQ.

Resizing: an array cannot grow

The length is fixed. Array.Resize creates a new array of the requested size, copies the elements, and updates the variable you pass by ref.

using System;

class Program
{
    static void Main()
    {
        string[] queue = { "Ana", "Ben" };
        string[] before = queue;

        Array.Resize(ref queue, 4);
        queue[2] = "Chloe";

        Console.WriteLine(queue.Length);
        Console.WriteLine(before.Length);             // the old array is unchanged
        Console.WriteLine(queue[3] == null);          // new slots get the default
        Console.WriteLine(ReferenceEquals(before, queue));
    }
}

Output:

4
2
True
False

Each resize copies every element. Growing an array one item at a time in a loop is slow and is exactly what List<T> does for you more efficiently, by doubling its internal array.

Arrays are reference types: copying

Assigning an array to another variable copies the reference, not the elements. Both names then point at the same array.

using System;

class Program
{
    static void Main()
    {
        int[] original = { 1, 2, 3 };

        int[] alias = original;
        alias[0] = 100;
        Console.WriteLine(original[0]); // 100: same array

        int[] copy = (int[])original.Clone();
        copy[1] = 200;
        Console.WriteLine(original[1]); // 2: independent array

        int[] target = new int[5];
        Array.Copy(original, 0, target, 1, 3); // source, start, dest, start, count
        Console.WriteLine(string.Join(", ", target));
    }
}

Output:

100
2
0, 100, 2, 3, 0

The same applies when you pass an array to a method: the method can change the caller's elements. Clone, Array.Copy, CopyTo and LINQ's ToArray() all make a shallow copy. For an array of objects, the new array holds references to the same objects, so changing copy[0].Name still changes what original[0] sees.

Comparing arrays with == compares references. To compare contents, use a.SequenceEqual(b) from System.Linq.

2D arrays (multidimensional)

A rectangular grid is declared with a comma inside the brackets. Index it with [row, col].

using System;

class Program
{
    static void Main()
    {
        int[,] seats = new int[2, 3]; // 2 rows, 3 columns
        seats[0, 1] = 1;
        seats[1, 2] = 1;

        int[,] grid =
        {
            { 1, 2, 3 },
            { 4, 5, 6 },
        };

        Console.WriteLine("Rows: " + grid.GetLength(0));
        Console.WriteLine("Cols: " + grid.GetLength(1));
        Console.WriteLine("Length: " + grid.Length + ", Rank: " + grid.Rank);

        for (int r = 0; r < seats.GetLength(0); r++)
        {
            for (int c = 0; c < seats.GetLength(1); c++)
            {
                Console.Write(seats[r, c] == 1 ? "X " : ". ");
            }
            Console.WriteLine();
        }
    }
}

Output:

Rows: 2
Cols: 3
Length: 6, Rank: 2
. X . 
. . X 

Length on a 2D array is the total element count (6 for a 2 by 3 grid), which is why nested loops use GetLength(0) and GetLength(1). Rank is the number of dimensions. Three dimensions work the same way: new int[4, 4, 4] and cube[x, y, z]. A foreach over a 2D array visits every element row by row.

Jagged arrays (arrays of arrays)

A jagged array int[][] is an array whose elements are themselves arrays, and each inner array can have its own length. It suits data like "orders per customer" where rows differ in size.

using System;

class Program
{
    static void Main()
    {
        int[][] orders = new int[3][]; // 3 rows, none created yet
        orders[0] = new[] { 20, 35 };
        orders[1] = new[] { 12 };
        orders[2] = new[] { 8, 15, 40, 22 };

        for (int i = 0; i < orders.Length; i++)
        {
            Console.WriteLine("Customer " + i + ": " + orders[i].Length
                + " orders, " + string.Join(", ", orders[i]));
        }

        int[][] empty = new int[2][];
        Console.WriteLine(empty[0] == null);
    }
}

Output:

Customer 0: 2 orders, 20, 35
Customer 1: 1 orders, 12
Customer 2: 4 orders, 8, 15, 40, 22
True

new int[3][] creates the outer array only; each row starts as null, and orders[0][0] before assigning a row throws NullReferenceException. The syntax new int[3][4] is not allowed; you create each row yourself.

Use [,] for a true grid (a board, a matrix, pixels) and [][] when rows have different lengths or you want to swap whole rows.

Array vs List

Converting is one call either way: new List<int>(arr) or arr.ToList(), and list.ToArray(). List<T> is the growable version.

Common mistakes

• i <= arr.Length in a loop. The last valid index is Length - 1; this throws IndexOutOfRangeException.
• Printing the array directly. Console.WriteLine(arr) prints System.Int32[]; use string.Join.
• Expecting Array.Sort to return the sorted array. It returns void and sorts in place.
• Copying with =. That copies the reference; use Clone() or ToArray().
• Using jagged rows before creating them. Each row of new T[n][] is null until assigned.
• Using Length for rows of a 2D array. It counts every element; use GetLength(0).