Understanding Arrays in C#

In today's lesson, we'll explore arrays in C#, a versatile and fundamental data structure. An array is an ordered collection of elements that can be of mixed data types. Arrays in C# are mutable, meaning their elements can be changed after creation. However, arrays can be made immutable using certain techniques if needed. The beauty of arrays lies in their simplicity and efficiency; they allow for easy storage, access, and manipulation of data. By the end of this lesson, you'll be able to create, manipulate, and understand the unique applications of arrays in C#.

Creating Arrays

Arrays are a fundamental part of C# programming, allowing you to define collections of elements of the same type. There are two primary ways to create arrays in C#: using array literals and using constructors with the new keyword. Array Literals : An array can be declared and initialized with specific values directly using an array literal. This involves enclosing the elements within curly braces {} without using the new keyword. Using Constructors : Arrays can also be created using the new keyword followed by the type, square brackets [], and the elements enclosed in curly brackets {} . This approach explicitly specifies the array's type and initializes it with values. It is considered best practice to declare arrays with readonly in C# when the reference to the array itself should not change, but the contents can. In the next C# example, we illustrate array creation using both array literals and constructors: C# using System; class ArrayExample {public (string[] arrayLiteral, string[] fromConstructor) CreateArrays() {string[] arrayLiteral = { "apple", "banana", "cherry" }; // Using array literals string[] fromConstructor = new string[] { "apple", "banana", "cherry" }; // Using constructor return (arrayLiteral, fromConstructor);}} class Program {static void Main() {var arrayExample = new ArrayExample(); var arrays = arrayExample.CreateArrays(); Console.WriteLine(string.Join(", ", arrays.arrayLiteral)); // Output: apple, banana, cherry Console.WriteLine(string.Join(", ", arrays.fromConstructor)); // Output: apple, banana, cherry}} This example demonstrates how to create arrays using both the array literal method and the constructor method, providing the same resulting arrays in both cases.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Inspecting and Modifying Arrays

Just like strings, array elements are accessible via indexes. Indexes in C# arrays are zero-based, meaning the first element has an index of 0, the second element has an index of 1, and so on. C# also introduces the ^ symbol, which allows accessing elements from the end of the array. For example, ^1 refers to the last element, ^2 to the second-to-last, and so on.

The Length property of an array returns the number of elements present in the array and can be used to easily determine its size or iterate over the array. Though arrays are mutable by default, you can create new arrays from existing ones or use Array.AsReadOnly() to enforce immutability.

Consider the following example that depicts inspecting, modifying arrays, and demonstrating the Length property:

using System;
using System.Collections.ObjectModel;

class ArrayExample
{
    public void InspectArray()
    {
        string[] myArray = { "apple", "banana", "cherry", "durian", "elderberry" };
        Console.WriteLine(myArray[1]);   // Output: banana
        Console.WriteLine(myArray[^1]);  // Output: elderberry

        string[] slice = new string[2];
        Array.Copy(myArray, 2, slice, 0, 2);
        Console.WriteLine(string.Join(", ", slice)); // Output: cherry, durian

        string[] newArray = { myArray[1], myArray[2], "dragonfruit" };
        Console.WriteLine(string.Join(", ", newArray)); // Output: banana, cherry, dragonfruit

        ReadOnlyCollection<string> readOnlyArray = Array.AsReadOnly(newArray);

        // Demonstrating the behavior that causes an exception
        // Uncomment the following line to see the runtime exception
        // readOnlyArray[0] = "blueberry";

        Console.WriteLine(string.Join(", ", readOnlyArray)); // Output: banana, cherry, dragonfruit
    }
}

class Program
{
    static void Main()
    {
        var arrayExample = new ArrayExample();
        arrayExample.InspectArray();
    }
}

using System;
using System.Collections.ObjectModel;

class ArrayExample
{
    public void InspectArray()
    {
        string[] myArray = { "apple", "banana", "cherry", "durian", "elderberry" };
        Console.WriteLine(myArray[1]);   // Output: banana
        Console.WriteLine(myArray[^1]);  // Output: elderberry

        string[] slice = new string[2];
        Array.Copy(myArray, 2, slice, 0, 2);
        Console.WriteLine(string.Join(", ", slice)); // Output: cherry, durian

        string[] newArray = { myArray[1], myArray[2], "dragonfruit" };
        Console.WriteLine(string.Join(", ", newArray)); // Output: banana, cherry, dragonfruit

        ReadOnlyCollection<string> readOnlyArray = Array.AsReadOnly(newArray);

        // Demonstrating the behavior that causes an exception
        // Uncomment the following line to see the runtime exception
        // readOnlyArray[0] = "blueberry";

        Console.WriteLine(string.Join(", ", readOnlyArray)); // Output: banana, cherry, dragonfruit
    }
}

class Program
{
    static void Main()
    {
        var arrayExample = new ArrayExample();
        arrayExample.InspectArray();
    }
}

Here's a deeper dive into some of the array methods and features used:

^ symbol allows accessing array elements from the end, with ^1 referring to the last element.
Array.Copy(myArray, 2, slice, 0, 2) copies a range of elements from one array to another, in this example, it copies 2 elements from myArray, starting at index 2, to the slice array, starting at index 0.
Length is a property that gives the total number of elements in the array.
Array.AsReadOnly(array) returns a read-only wrapper for the specified array.

Operations on Arrays

C# arrays allow a range of operations. LINQ (Language Integrated Query) is a powerful feature in C# that provides query capabilities directly in the C# language, enabling more concise and readable code when performing operations on collections, such as arrays. Here's an overview of some common operations using LINQ on arrays:

The Concat() method using LINQ concatenates two arrays, while loops or the Enumerable.Repeat() method can be used to repeat elements of an array. The Contains() method checks if a particular item is present in the array. Additionally, the Select() method using LINQ creates a new array populated with the results of calling a provided function on every element in the array.

Here's an example demonstrating these operations:

using System;
using System.Linq;

class ArrayExample
{
    public void ArrayOperations()
    {
        string[] array1 = { "apple", "banana" };
        string[] array2 = { "cherry", "durian" };
        var array3 = array1.Concat(array2).ToArray();
        Console.WriteLine(string.Join(", ", array3)); // Output: apple, banana, cherry, durian

        var array4 = Enumerable.Repeat(array1, 3).SelectMany(e => e).ToArray();
        Console.WriteLine(string.Join(", ", array4)); // Output: apple, banana, apple, banana, apple, banana

        Console.WriteLine(array1.Contains("apple"));  // Output: True
        
        var mappedArray = array1.Select(fruit => $"{fruit} pie").ToArray();
        Console.WriteLine(string.Join(", ", mappedArray)); // Output: apple pie, banana pie
    }
}

class Program
{
    static void Main()
    {
        var arrayExample = new ArrayExample();
        arrayExample.ArrayOperations();
    }
}

using System;
using System.Linq;

class ArrayExample
{
    public void ArrayOperations()
    {
        string[] array1 = { "apple", "banana" };
        string[] array2 = { "cherry", "durian" };
        var array3 = array1.Concat(array2).ToArray();
        Console.WriteLine(string.Join(", ", array3)); // Output: apple, banana, cherry, durian

        var array4 = Enumerable.Repeat(array1, 3).SelectMany(e => e).ToArray();
        Console.WriteLine(string.Join(", ", array4)); // Output: apple, banana, apple, banana, apple, banana

        Console.WriteLine(array1.Contains("apple"));  // Output: True
        
        var mappedArray = array1.Select(fruit => $"{fruit} pie").ToArray();
        Console.WriteLine(string.Join(", ", mappedArray)); // Output: apple pie, banana pie
    }
}

class Program
{
    static void Main()
    {
        var arrayExample = new ArrayExample();
        arrayExample.ArrayOperations();
    }
}

Here’s a breakdown of the array methods used:

Concat(anotherArray) from LINQ returns a new array that is the result of joining two or more arrays.
Enumerable.Repeat(value, n) creates a sequence with n copies of the value.
SelectMany(e => e).ToArray() is used to flatten a sequence of sequences into a single sequence. In this example, it flattens the repeated sequences into one continuous array.
Contains(element) checks if the array includes a certain element and returns true or false.
Select(callback) from LINQ creates a new array populated with the results of calling a provided function on every element in the array. In this case, we use a lambda function fruit => $"{fruit} pie" for concise syntax.

Nested Arrays

An array can contain another array, resulting in a nested array. In a nested array, you can access elements by chaining indices. The first index accesses an element within the top-level array, and the subsequent index(es) access elements within the sub-array. Here's an example of creating and indexing a nested array:

using System;

class ArrayExample
{
    public object[] CreateNestedArray()
    {
        return new object[] { "apple", new object[] { "banana", "cherry" } };
    }
}

class Program
{
    static void Main()
    {
        var arrayExample = new ArrayExample();
        var nestedArray = arrayExample.CreateNestedArray();
        Console.WriteLine(nestedArray[0]); // Output: apple
        Console.WriteLine(nestedArray[1]); // Output: System.Object[]

        var subArray = (object[])nestedArray[1];
        Console.WriteLine(subArray[0]); // Output: banana
        Console.WriteLine(subArray[1]); // Output: cherry
    }
}

using System;

class ArrayExample
{
    public object[] CreateNestedArray()
    {
        return new object[] { "apple", new object[] { "banana", "cherry" } };
    }
}

class Program
{
    static void Main()
    {
        var arrayExample = new ArrayExample();
        var nestedArray = arrayExample.CreateNestedArray();
        Console.WriteLine(nestedArray[0]); // Output: apple
        Console.WriteLine(nestedArray[1]); // Output: System.Object[]

        var subArray = (object[])nestedArray[1];
        Console.WriteLine(subArray[0]); // Output: banana
        Console.WriteLine(subArray[1]); // Output: cherry
    }
}

In this example, the nestedArray contains a mix of strings and another array. The line var subArray = (object[])nestedArray[1]; is performing an explicit type casting. The element at nestedArray[1] is actually an array of object, and by casting it to object[], we can safely access its elements using indices. Explicit type casting is necessary here as the C# compiler needs an assurance of the type before accessing elements, especially when dealing with heterogeneous collections like arrays of object.

Array destructuring isn't as straightforward in C# as it is in JavaScript, but you can manually extract values by indexing. For more complex destructuring scenarios, you might need to use tuples or custom objects.

Complex Nested Arrays and Advanced Concepts

You can create complex nested arrays where each element can be an object containing arrays. Consider the following example with car manufacturers and their models:

using System;

class Car
{
    public string Name { get; set; } = string.Empty;
    public string[] Models { get; set; } = Array.Empty<string>();
}

class ArrayExample
{
    public Car[] CreateNestedObjectArray()
    {
        return new Car[]
        {
            new Car { Name = "Ford", Models = new string[] { "Fiesta", "Focus", "Mustang" } },
            new Car { Name = "BMW", Models = new string[] { "320", "X3", "X5" } },
            new Car { Name = "Fiat", Models = new string[] { "500", "Panda" } }
        };
    }
}

class Program
{
    static void Main()
    {
        var arrayExample = new ArrayExample();
        var cars = arrayExample.CreateNestedObjectArray();
        foreach (var car in cars)
        {
            Console.WriteLine($"{car.Name}: {string.Join(", ", car.Models)}");
        }

        // Access elements in the nested object array
        Console.WriteLine(string.Join(", ", cars[0].Models)); // Output: Fiesta, Focus, Mustang
        Console.WriteLine(cars[1].Name);   // Output: BMW
        Console.WriteLine(cars[2].Models[1]); // Output: Panda
    }
}

using System;

class Car
{
    public string Name { get; set; } = string.Empty;
    public string[] Models { get; set; } = Array.Empty<string>();
}

class ArrayExample
{
    public Car[] CreateNestedObjectArray()
    {
        return new Car[]
        {
            new Car { Name = "Ford", Models = new string[] { "Fiesta", "Focus", "Mustang" } },
            new Car { Name = "BMW", Models = new string[] { "320", "X3", "X5" } },
            new Car { Name = "Fiat", Models = new string[] { "500", "Panda" } }
        };
    }
}

class Program
{
    static void Main()
    {
        var arrayExample = new ArrayExample();
        var cars = arrayExample.CreateNestedObjectArray();
        foreach (var car in cars)
        {
            Console.WriteLine($"{car.Name}: {string.Join(", ", car.Models)}");
        }

        // Access elements in the nested object array
        Console.WriteLine(string.Join(", ", cars[0].Models)); // Output: Fiesta, Focus, Mustang
        Console.WriteLine(cars[1].Name);   // Output: BMW
        Console.WriteLine(cars[2].Models[1]); // Output: Panda
    }
}

This demonstrates how nested arrays can be used in complex structures, making it easier to organize and access data.

Understanding Arrays in C#