🚀 𝗜𝗻𝗹𝗶𝗻𝗲 𝗔𝗿𝗿𝗮𝘆𝘀 & 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻𝘀 𝗶𝗻 𝗖# 𝟭𝟮: 𝗕𝗼𝗼𝘀𝘁𝗶𝗻𝗴 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 !

C# continues to evolve, and with the upcoming release of C# 12, developers are getting excited about new features that enhance performance and code readability. Two standout features are Inline Arrays and Collection Expressions. Let’s dive into what they offer and how they can improve your code.

🚀 Collection Expressions — Streamlining Collections

Initializing collections has always been a bit verbose in C#. With C# 12, Collection Expressions introduce a more concise syntax for creating collections, making your code cleaner and more readable.

Before C# 12:

var numbers = new List<int> { 1, 2, 3 };
var otherNumbers = new List<int> { 4, 5, 6 };
numbers.AddRange(otherNumbers);

With C# 12:

var numbers = [1, 2, 3, ..otherNumbers];

Explanation:

• [ ] Bracket Notation: Similar to array initialization, but for collections.

• .. Spread Operator: Allows you to include all elements from another collection.

Benefits:

• Conciseness: Reduces the amount of code needed to initialize collections.

• Readability: Makes it easier to understand what elements are included.

• Flexibility: Works with various collection types that implement. IEnumerable.

Example Usage:

var primes = [2, 3, 5, 7];
var morePrimes = [11, 13, 17];
var allPrimes = [..primes, ..morePrimes, 19, 23];

Console.WriteLine(string.Join(", ", allPrimes));
// Output: 2, 3, 5, 7, 11, 13, 17, 19, 23

⚡ Inline Arrays — Boosting Performance

Performance-critical applications often require efficient memory usage. Inline Arrays in C# 12 allow you to define fixed-size arrays directly within a struct, optimizing memory layout and reducing heap allocations.

Before C# 12:

public struct Buffer
{
    private int[] _array;

    public Buffer(int size)
    {
        _array = new int[size];
    }

    public Span<int> Data => _array;
}

With C# 12:

public struct Buffer
{
    private int _data[10];

    public Span<int> Data => _data;
}

Explanation:

• Inline Array Declaration: Define an array with a fixed size directly in the struct (int _data[10];).

• No Heap Allocation: The array is stored inline with the struct, avoiding separate heap allocations.

• Span Compatibility: Easily create spans over the inline array for safe, efficient access.

Benefits:

• Performance: Reduces memory allocations and improves cache locality.

• Safety: Works seamlessly with Span<T> and MemoryMarshal for safe memory operations.

• Simplicity: Cleaner syntax for defining fixed-size buffers.

Example Usage:

public struct FixedBuffer
{
    private int _values[5];

    public FixedBuffer(int[] initialValues)
    {
        for (int i = 0; i < _values.Length; i++)
        {
            _values[i] = initialValues[i];
        }
    }

    public Span<int> Values => _values;

    public void PrintValues()
    {
        foreach (var value in _values)
        {
            Console.WriteLine(value);
        }
    }
}

var buffer = new FixedBuffer(new int[] { 1, 2, 3, 4, 5 });
buffer.PrintValues();
// Output:
// 1
// 2
// 3
// 4
// 5

🎯 Key Takeaways

• Collection Expressions simplify collection initialization, making code more concise and readable.

• Inline Arrays improve performance by reducing heap allocations and enhancing memory efficiency.

• These features help write cleaner, more efficient code in performance-critical and everyday applications.

Note: As of my knowledge cutoff in October 2023, C# 12 features are still in preview and may be subject to change. Make sure to check the latest official documentation or release notes for the most accurate information.

Are you excited about these new features in C# 12? How do you plan to use Collection Expressions and Inline Arrays in your projects? Share your thoughts below! 💬

Please follow me on LinkedIn: Apurv Upadhyay ☁️

#CSharp #DotNet #Programming #NewFeatures #CodeQuality #Developers