;

C# Arrays

Arrays are a fundamental part of programming in C#. They provide a structured way to store multiple values of the same type in a single variable. Understanding arrays is crucial because they form the basis for more complex data structures and algorithms. 

In this tutorial, we explored the concept of arrays in C# in detail. We covered the topics like What arrays are and their types, How to declare, initialize, and access arrays., Common operations you can perform on arrays, such as sorting, reversing, and finding the length and a real-world example where arrays are used.

Table of Contents

What is an Array in C#?

An array in C# is a collection of elements, all of which are of the same type, stored in contiguous memory locations. Arrays provide an efficient way to store and access a sequence of values, whether they are integers, strings, or other types. The array’s size is fixed once it’s declared, and the index-based access to its elements makes operations fast.

Characteristics of Arrays

  • Fixed Size: Once an array is initialized, its size cannot be changed.
  • Same Type Elements: All elements in an array must be of the same data type.
  • Indexed Access: Array elements are accessed using an index that starts from 0.
  • Efficient Memory Management: Arrays are allocated in contiguous blocks of memory, which makes them efficient for reading and writing operations.

Types of Arrays in C#

C# supports different types of arrays to handle various use cases.

Single-Dimensional Arrays

The most basic type of array is the single-dimensional array, which represents a list of elements in a straight line, indexed starting from 0.

Syntax

dataType[] arrayName = new dataType[size];

Example

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

Multi-Dimensional Arrays

Multi-dimensional arrays store data in a grid, table, or matrix form. The most common is the two-dimensional array.

Syntax

dataType[,] arrayName = new dataType[rows, columns];

Example

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

Jagged Arrays

A jagged array is an array of arrays. Each "sub-array" can have different lengths, making it suitable for irregular data structures like triangle matrices.

Syntax

dataType[][] arrayName = new dataType[size][];

Example

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

Declaring and Initializing Arrays

There are several ways to declare and initialize arrays in C#. You can initialize an array without specifying the size if you provide the values directly.

Example: Declaration Without Initialization

int[] numbers;

Example: Declaration With Size

int[] numbers = new int[5]; // This creates an array with 5 elements initialized to 0.

Example: Declaration and Initialization with Values

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

Accessing Array Elements

Once an array is declared and initialized, its elements can be accessed using indices. The index starts from 0, meaning the first element is at position 0.

Example

int[] numbers = {10, 20, 30, 40, 50};
Console.WriteLine(numbers[0]);  // Output: 10
numbers[2] = 35;  // Update the third element to 35

If you try to access an index outside the bounds of the array, it throws an IndexOutOfRangeException.

Common Operations on Arrays

Looping Through an Array

You can loop through an array using a for or foreach loop.

Example: for Loop

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

Example: foreach Loop

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

Finding the Length of an Array

You can find the number of elements in an array using the Length property.

int length = numbers.Length;  // Output: 5

Sorting an Array

Array.Sort(numbers);

Reversing an Array

Array.Reverse(numbers);

Real-World Example: Managing Product Inventory

Let’s consider a real-world scenario where you need to manage product inventory in a store. Each product has a price, and you want to store the prices of all products in an array and find the highest price.

Problem:

You are developing an application for a store that tracks the prices of products. You want to calculate the highest price in the inventory.

Solution:

We can use a single-dimensional array to store product prices and iterate through the array to find the highest price.

class Store
{
    static void Main(string[] args)
    {
        double[] prices = new double[5];
        
        // Input prices for products
        for (int i = 0; i < prices.Length; i++)
        {
            Console.Write($"Enter price for product {i + 1}: ");
            prices[i] = double.Parse(Console.ReadLine());
        }

        // Finding the highest price
        double highestPrice = prices[0];
        for (int i = 1; i < prices.Length; i++)
        {
            if (prices[i] > highestPrice)
            {
                highestPrice = prices[i];
            }
        }

        Console.WriteLine($"The highest price is: {highestPrice}");
    }
}
Explanation:
  • We create a prices array to store the prices of products.
  • We use a loop to take input from the user.
  • We then find the highest price by iterating through the array.

Output:

Enter price for product 1: 10.5
Enter price for product 2: 20.0
Enter price for product 3: 15.75
Enter price for product 4: 25.0
Enter price for product 5: 22.5
The highest price is: 25.0

Key Takeaways

  • Fixed Size: Arrays have a fixed size, so they are efficient when you know the number of elements beforehand.
  • Single-Dimensional, Multi-Dimensional, and Jagged Arrays: C# supports different types of arrays to accommodate various data structures.
  • Efficient Data Access: Arrays provide fast access to elements through indexing.
  • Use Cases: Arrays are widely used for managing collections of data, such as product prices, game scores, or sensor data.
  • Real-World Relevance: Arrays are ideal for applications like managing inventories, performing matrix operations, or handling structured data in fixed sizes.

Summary

Arrays are a core feature of C# that you’ll frequently use in both simple and complex applications. They offer a way to efficiently handle fixed-size collections of data, making them a crucial tool in software development.

By mastering arrays, you can lay a strong foundation for more advanced data structures like lists, dictionaries, and custom collections.