Simplifying Collections with C# 12 Collection Expressions

With the release of C# 12, developers gain access to several powerful features aimed at improving productivity and code clarity. One of the standout features is the new collection expressions. This feature simplifies the creation of various collections, making the syntax more concise and the code more readable.

Connect with Me https://linktr.ee/ICodeMechanic

What are Collection Expressions?

Collection expressions are a new way to initialize collections in C# using a streamlined and intuitive syntax. This feature builds on the existing array initializer syntax, extending its capabilities to other collection types like lists and dictionaries.

Why Use Collection Expressions?

• Concise Syntax: Reduces boilerplate code and enhances readability.
• Consistency: Provides a uniform way to initialize different types of collections.
• Ease of Use: Familiar syntax similar to array initializers, making it easy to adopt.

How to Use Collection Expressions

Initializing a List

Before C# 12, initializing a list required more verbose code:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

With collection expressions, the syntax is more concise:

List<int> numbers = [1, 2, 3, 4, 5];

Initializing an Array

Similarly, initializing an array is straightforward:

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

Initializing a Dictionary

Initializing dictionaries also becomes simpler with collection expressions:

Dictionary<int, string> numberNames = [1 => "One", 2 => "Two", 3 => "Three"];

Detailed Examples

Example 1: List Initialization

Let’s look at a detailed example where we initialize and manipulate a list of integers.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = [1, 2, 3, 4, 5];
        
        // Print all numbers
        Console.WriteLine("List of numbers:");
        numbers.ForEach(Console.WriteLine);
        
        // Add a number to the list
        numbers.Add(6);
        Console.WriteLine("\nAfter adding 6:");
        numbers.ForEach(Console.WriteLine);
        
        // Remove a number from the list
        numbers.Remove(3);
        Console.WriteLine("\nAfter removing 3:");
        numbers.ForEach(Console.WriteLine);
    }
}

Example 2: Array Initialization

Initializing and using arrays with collection expressions is equally straightforward.

using System;

class Program
{
    static void Main()
    {
        int[] numbers = [1, 2, 3, 4, 5];

        Console.WriteLine("Array of numbers:");
        foreach (var number in numbers)
        {
            Console.WriteLine(number);
        }

        // Accessing an element
        Console.WriteLine($"\nElement at index 2: {numbers[2]}");

        // Updating an element
        numbers[2] = 99;
        Console.WriteLine("\nArray after updating index 2:");
        foreach (var number in numbers)
        {
            Console.WriteLine(number);
        }
    }
}

Example 3: Dictionary Initialization

Creating dictionaries with collection expressions is particularly powerful, reducing boilerplate code significantly.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Dictionary<int, string> numberNames = [1 => "One", 2 => "Two", 3 => "Three"];

        Console.WriteLine("Dictionary of number names:");
        foreach (var kvp in numberNames)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }

        // Adding a new key-value pair
        numberNames[4] = "Four";
        Console.WriteLine("\nAfter adding 4:");
        foreach (var kvp in numberNames)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }

        // Removing a key-value pair
        numberNames.Remove(2);
        Console.WriteLine("\nAfter removing 2:");
        foreach (var kvp in numberNames)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

Benefits of Using Collection Expressions

1. Improved Readability: By reducing the verbosity of collection initialization, your code becomes cleaner and easier to read.
2. Less Boilerplate Code: Fewer lines of code mean less potential for errors and a more maintainable codebase.
3. Consistent Syntax: A unified way of initializing collections across different types makes your code more predictable.

Conclusion

The introduction of collection expressions in C# 12 is a significant enhancement for developers. It simplifies the process of creating and initializing collections, leading to more readable and maintainable code. Whether you’re working with lists, arrays, or dictionaries, collection expressions provide a concise and powerful syntax to streamline your code.

Connect with Me https://linktr.ee/ICodeMechanic