• author: Nick Chapsas

Dotnet 8: Solving the Issue with Immutable Arrays in C

By Nick


In this video, I will demonstrate how dotnet 8 finally addresses one of the biggest challenges when using immutable arrays in C#. If you have never used immutable arrays before, it is crucial to understand the importance of selecting the appropriate data type for your application. Using the wrong type, such as arrays or lists, can lead to inefficiencies and potential issues down the line. In this article, we will explore the benefits of using immutable arrays, discuss the problem they solve, and how dotnet 8 simplifies the process of working with them.

Importance of Choosing the Right Data Type

Before we delve into the details, it is essential to emphasize the significance of selecting the appropriate data type for the task at hand. Using arrays or lists for every scenario may not be the most efficient approach. Instead, we should aim to use the right type for the right job. Immutable arrays, in particular, are well-suited for scenarios requiring an unchangeable collection of data. They ensure data integrity and provide a foundation for efficient and reliable code.

The Issue with Immutable Arrays

To illustrate the problem with immutable arrays, let's consider a scenario where we have an array of users. We generate this array using the Faker library, which allows us to create realistic-looking fake data. The issue arises when we attempt to convert this mutable array of users into an immutable array.


While this may seem like a logical solution, the ToImmutableArray() method actually creates a brand new array, copying the contents of the original array. This process can be costly in terms of both memory allocation and performance.

A Hacky Solution Before dotnet 8

Prior to the introduction of dotnet 8, there were workarounds to achieve immutable arrays. However, these solutions were often convoluted and not ideal. In the video, I demonstrate one such workaround. However, with the advent of dotnet 8, this problem has been significantly simplified.

Introducing dotnet 8

Dotnet 8 provides a streamlined solution for working with immutable arrays, making it much easier to create and utilize them. Let me demonstrate the improvements dotnet 8 brings:

  1. Effortless Fix: Dotnet 8 offers a straightforward way to create immutable arrays without the need for complex workarounds. This eliminates any potential performance bottlenecks and ensures efficient memory utilization.

  2. Internal Array Access: If you have exclusive ownership of an array and want to provide an efficient immutable array view of it, dotnet 8 enables you to achieve this. By leveraging the unsafe and unsafe as features, you can create a safe, immutable array that doesn't require a complete reallocation of memory.

Benchmarking Performance

To illustrate the performance difference, I conducted a benchmark using the benchmark class. This benchmark measures the speed and memory allocation of the ToImmutableArray() method for arrays of 100 and 10,000 items.

  • For 100 items, the process took 55 nanoseconds and allocated 824 bytes of memory.
  • For 10,000 items, the process took 2.7 microseconds and allocated 80 kilobytes of memory.

These results highlight the scalability of the ToImmutableArray() method. While memory allocation scales as expected, the speed differs slightly due to internal optimizations within dotnet 8.

Providing an Efficient Immutable Array View

Suppose you want to provide an immutable array view without having to reallocate the entire array. While directly using an immutable array of users is not possible due to internal restrictions, dotnet 8 offers a workaround.

  1. Unsafe Operations: By utilizing the unsafe and unsafe as methods, you can achieve an efficient immutable array view.

  2. Limited Use Case: It is essential to note that this approach is only valid if you are the sole owner of the array and do not plan on modifying it. Otherwise, changes made to the original array will impact the immutable array as well.

Improving Performance and Memory Efficiency with Immutable Arrays in .NET

One common challenge in software development is to ensure efficient memory usage while maintaining high performance. In .NET, there have been some recent improvements that address this issue, particularly when working with arrays of objects.

The Problem with Mutable Arrays

Traditionally, when working with arrays in .NET, we tend to use mutable arrays. This means that we can modify the elements of the array, which may lead to some performance and memory allocation concerns.

For example, let's consider a scenario where we have an array of users. If we pass this array around and make modifications to it in different methods or parts of our codebase, it can become difficult to track changes and ensure the array remains consistent. This can lead to bugs, performance issues, and unnecessary memory usage.

Enter Immutable Arrays

To address these challenges, .NET introduced the concept of immutable arrays. Immutable arrays, as the name suggests, cannot be modified once created. This means that they provide a safer and more efficient way to handle arrays of objects.

With immutable arrays, we can ensure that the array remains unchanged throughout our codebase, guaranteeing consistency and reducing the chances of introducing bugs. Additionally, since immutable arrays do not allow modifications, they do not require memory allocation every time a change is made, resulting in improved performance and memory efficiency.

Using Immutable Arrays in .NET

To utilize immutable arrays in .NET, we can leverage the ImmutableArray class provided by the System.Collections.Immutable namespace. Let's take a look at how we can use immutable arrays in our code.

// Create an immutable array of usersImmutableArray<User>immutableArray=ImmutableArray.Create<User>(users);// Pass the immutable array by referenceDoSomethingWithImmutableArray(refimmutableArray);

In the code snippet above, we create an immutable array of User objects using the ImmutableArray.Create<T> method. We then pass this immutable array by reference to a method called DoSomethingWithImmutableArray. By passing the array by reference, we avoid unnecessary memory allocations and ensure that the array remains immutable throughout the method's execution.

Benchmarking the Performance

To demonstrate the improvements in performance and memory efficiency offered by immutable arrays, let's run a benchmark comparing the use of mutable arrays and immutable arrays.

// Benchmark using mutable arrayBenchmarkUsingMutableArray();// Benchmark using immutable arrayBenchmarkUsingImmutableArray();// Benchmark comparing both approachesBenchmarkComparingApproaches();

In the benchmark, we compare the performance of both mutable and immutable arrays. The results clearly show that the immutable array approach is significantly more efficient, as it does not incur additional memory allocations and scales consistently, regardless of the number of elements in the array.

New Features in .NET 8

It's worth mentioning that with the release of .NET 8, additional features have been introduced to further enhance the usage of immutable arrays. One of these features is the ImmutableCollectionMarshal.AsImmutableArray method, which allows us to convert a mutable array to an immutable array without the need for the ref keyword.


In the code example above, we use the ImmutableCollectionMarshal.AsImmutableArray method to convert a mutable usersArray to an immutable array of User objects. This method provides the same performance benefits as before while simplifying the code and eliminating the need for passing arrays by reference.

Cautionary Notes

Although immutable arrays offer significant performance and memory efficiency advantages, it's important to exercise caution when using them. Both the AsImmutableArray and AsArray methods provide direct access to the internal backing array of the immutable array, which can be dangerous if not handled properly.

Any modification made to the backing array will affect the immutable array since it merely references the same memory. Therefore, it's crucial to ensure that only safe and necessary operations are performed on the backing array.

Your Thoughts?

What are your thoughts on using immutable arrays in .NET? Have you encountered similar challenges with memory usage and performance? Share your experiences and thoughts in the comments below.

That concludes this article on improving performance and memory efficiency with immutable arrays in .NET. Thank you for reading, and happy coding!Choosing the appropriate data type is essential for efficient and robust code. with dotnet 8, working with immutable arrays becomes more accessible and efficient, eliminating the need for convoluted workarounds. the streamlined process of creating immutable arrays ensures optimal memory utilization and addresses performance concerns. by understanding the benefits and limitations of immutable arrays, developers can enhance their code and create more reliable applications.

for more content and training resources, make sure to subscribe and check out my courses on domtrain.com. additionally, i am excited to announce the launch of my latest course, "from zero to hero: logging in .net." logging is a fundamental aspect of any .net application, and mastering it is crucial for creating robust and maintainable code. to celebrate the course release, i am offering a special discount of 20% off for the first 400 viewers. use the code "log20" during your purchase to claim your discount.

now that we have covered the fundamentals, let's dive into the problem and explore how dotnet 8 revolutionizes working with immutable arrays.

Previous Post

The Most Important JSON Web Token (JWT) Setting You're Probably Ignoring

Next Post

The Three Biggest Mistakes of Object Mapping in C

About The auther

New Posts

Popular Post