C# - Create an Array

Create an Array in C#

Introduction

Arrays are one of the fundamental data structures in C#. They allow developers to store multiple items of the same type in a single variable. This capability is essential for scenarios involving iteration, storage, and manipulation of data. Arrays are fixed in size once initialized and provide fast access to elements via indexing. In this guide, we will explore arrays in-depth, from creation and initialization to advanced usage and best practices.

What is an Array?

An array is a data structure that holds a fixed number of values of the same type. The elements in an array are accessed by their index, which starts at 0. Arrays in C# are zero-based, meaning the index of the first element is 0.

Declaration and Initialization

Declaring an Array

int[] numbers;

This line declares an array of integers. However, it does not allocate memory.

Initializing an Array

numbers = new int[5];

This creates an array of 5 integers with default values (0 for int).

Declaration and Initialization in One Line

int[] numbers = new int[5];

Array with Initialization Values

int[] numbers = new int[] { 1, 2, 3, 4, 5 };

C# also allows the shorthand syntax:

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

Accessing Elements

Each element can be accessed by its index.

Console.WriteLine(numbers[0]); // Outputs 1

Modifying Elements

numbers[2] = 100; // Changes third element to 100

Length Property

The Length property returns the total number of elements.

Console.WriteLine(numbers.Length);

Types of Arrays

• Single-Dimensional Arrays
• Multi-Dimensional Arrays
• Jagged Arrays

Single-Dimensional Arrays

string[] names = { "Alice", "Bob", "Charlie" };

Multi-Dimensional Arrays

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

Accessing an element:

matrix[0, 1] = 10;

Jagged Arrays

An array of arrays:

int[][] jaggedArray = new int[2][];
jaggedArray[0] = new int[] { 1, 2 };
jaggedArray[1] = new int[] { 3, 4, 5 };

Looping Through Arrays

Using for Loop

for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

Using foreach Loop

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Common Operations

Sorting Arrays

Array.Sort(numbers);

Reversing Arrays

Array.Reverse(numbers);

Finding Elements

int index = Array.IndexOf(numbers, 3);

Copying Arrays

int[] copy = new int[numbers.Length];
Array.Copy(numbers, copy, numbers.Length);

Passing Arrays to Methods

void PrintArray(int[] arr)
{
    foreach (int i in arr)
    {
        Console.WriteLine(i);
    }
}

Returning Arrays from Methods

int[] GetArray()
{
    return new int[] { 1, 2, 3 };
}

Advanced Topics

Using LINQ with Arrays

int[] evenNumbers = numbers.Where(n => n % 2 == 0).ToArray();

Using Array Class Methods

bool exists = Array.Exists(numbers, x => x > 10);
int found = Array.Find(numbers, x => x > 10);

Clearing Array Elements

Array.Clear(numbers, 0, numbers.Length);

Memory and Performance

Arrays are stored in contiguous memory blocks, making access very efficient. However, since their size is fixed, dynamic data structures like List<T> are often preferred for scenarios with changing data sizes.

Common Mistakes

• Accessing out-of-bound indexes (IndexOutOfRangeException)
• Not initializing arrays before use
• Misusing jagged vs multidimensional arrays

Arrays are a powerful and efficient data structure in C#. They provide quick access to elements, are simple to use, and are essential for various programming tasks. Understanding how to declare, initialize, and manipulate arrays opens the door to more complex data handling and algorithm design. Whether you're building simple applications or high-performance systems, arrays will be a core component of your C# toolkit.