Create an ImmutableArray without copying

Question

Is there any way (possibly a dirty hack) to create an ImmutableArray which will just use a specified array, instead of copying it over?

I have an array which I know won't change, and I want to create an ImmutableArray to allow clients to access my array safely.

Looking at the source code for ImmutableArray, I see the Create method will not help:

public static ImmutableArray<T> Create<T>(params T[] items)
{
    if (items == null)
    {
        return Create<T>();
    }

    // We can't trust that the array passed in will never be mutated by the caller.
    // The caller may have passed in an array explicitly (not relying on compiler params keyword)
    // and could then change the array after the call, thereby violating the immutable
    // guarantee provided by this struct. So we always copy the array to ensure it won't ever change.
    return CreateDefensiveCopy(items);
}

Edit: There is a request for exactly this feature on GitHub, which also gives the quickest hack to use: https://github.com/dotnet/corefx/issues/28064

Slocum

Why not simply use a usual array if you know your element won´t change? – Fuzz

Why are you trying to avoid copying? Is this casting performance problems? are you optimising prematurely? – Lantern

@sweeper. performance. It's for a vector library, and so has to be fast. An extra iteration through an array in vector.Add would about halve performance – Slocum

@HimBromBeere. Because I need to give readonly access to the array to client code – Slocum

What about returning an IReadOnlyList<T>? – Stanwood

I suppose ReadOnlySpan<T> should solve this. But I'm not sure it's available for use yet? – Asymmetric

@Stanwood array.asreadonly returns a readonlycollction, which gives access to the original array, so i would have to implement it myself. Using a prebuilt type is generally nicer – Slocum

Answer 1

There is also another two hacky approaches, both suggested here: https://mcmap.net/q/1241606/-c-convert-struct-to-another-struct (one in answer, one in comment).

1. Marshal one struct type to another.
2. Unsafely cast one to another.

First one involves creating a new struct type that mirrors layout of ImmutableArray (which is a single T[] field) and changing the type of that struct as seen by CLR (runtime). The struct would look like this:

public struct HackImmutableArray<T>
{
    public T[] Array;
}

1. Marshalling:

   static ImmutableArray<T> HackyMakeImmutable<T>(T[] array)
   {
       var arrayObject = (object)new HackImmutableArray<T> { Array = array };
       var handle = GCHandle.Alloc(arrayObject, GCHandleType.Pinned);
       var immutable = (ImmutableArray<T>)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
       handle.Free();
       return immutable;
   }
   

2. Unsafe casting (nice helpers written here, found in this blog post). Casting uses Unsafe static class available in System.Runtime.CompilerServices.Unsafe NuGet

   using System.Runtime.CompilerServices;
   
   static ImmutableArray<T> HackyMakeImmutable<T>(T[] array)
   {
       return Unsafe.As<T[], ImmutableArray<T>>(ref array);
   }
   

The second option is "not safe" but quite safe, as we can with certainty assume ImmutableArray's struct layout not to change, being a defining feature, and it'll also be probably much faster than any other solution.

Shyamal

Answer 2

If you know the exact length of the array, you can use the ImmutableArray.CreateBuilder<> plus the .MoveToImmutable() that will create an ImmutableArray<> from the internals of the Builder without copying it:

var builder = ImmutableArray.CreateBuilder<int>(4);
builder.Add(1);
builder.Add(2);
builder.Add(3);
builder.Add(4);
ImmutableArray<int> array = builder.MoveToImmutable();

The method .MoveToImmutable() will throw an exception if builder.Capacity != builder.Count

Note that other methods of the builder (like .ToImmutable()) will create a copy of the array.

Kraus

When building a new immutable array from scratch, this is the best solution. When there is already an array that just needs to be made immutable, this does not help, though, as it still requires copying the array. Might be worth including this info in the answer. – Konstanz

Answer 3

In .NET 8 preview no need to use Unsafe anymore.

They exposed some additional methods to access the internal constructor.

Use ImmutableCollectionsMarshal.AsImmutableArray<T>:

ImmutableArray<T> im = ImmutableCollectionsMarshal.AsImmutableArray(array);

Boccie

Answer 4

At https://github.com/dotnet/corefx/issues/28064 They recommend the fastest way is using System.Runtime.CompilerServices.Unsafe:

ImmutableArray<T> im = Unsafe.As<T[], ImmutableArray<T>>(ref array);

Slocum

Answer 5

This is probably a bad idea, and they can use the same trick against you, but you can cheat with reflection:

public static ImmutableArray<T> GetImmutableArray<T>(T[] arr)
{
    var immutableArray = ImmutableArray.Create(new T[0]);
    var boxed = ((object) immutableArray);
    var t = boxed.GetType();
    var fi = t.GetField("array", BindingFlags.NonPublic | BindingFlags.Instance);
    fi.SetValue(boxed, arr);
    return (ImmutableArray<T>)boxed;
}

And call it like this:

var arr = new int[] { 1, 2, 3 };
Console.WriteLine("Arr: " + string.Join(",", arr)); //Arr: 1,2,3
var imm = GetImmutableArray(arr);
Console.WriteLine("ImmutableArray: " + string.Join(",", imm)); //ImmutableArray: 1,2,3
arr[0] = 234;
imm[0] = 235; //Compile Error
Console.WriteLine("ImmutableArray: " + string.Join(",", imm)); //ImmutableArray: 234,2,3

The reflection cost would have to be weighed against the Array.Copy cost.

Stanwood

@ MineR I love bad ideas. Always makes me feel like more of a programmer ;-). Thanks for this. I'll hold back on it unless really necessary, but it might just come in useful. – Slocum

Answer 6

ReadOnlyCollection<T> could be used to achieve the same purpose in many cases. It is not true it gives access to the original array -- the Items property is protected.

There are two downsides to using ReadOnlyCollection<T> instead of ImmutableArray<T>, though:

1. An extra allocation takes place. ReadOnlyCollection<T> is a class wrapping an IList<T>, while ImmutableArray<T> is a struct wrapping an T[].
2. The receiver of the collection has weaker guarantees about immutability. The collection cannot be modified from the outside, but whoever created it may still hold a reference to the original array and may use it to modify the collection.

The guarantee that no such modifications will take place can be provided by documentation, but it is still a somewhat weaker guarantee than the technically enforced one.

Konstanz

"The receiver of the collection has weaker guarantees about immutability." It's more like "the receiver of the collection has no guarantees about immutability" IMHO. – Kucik

There are many types of immutability, @TheodorZoulias. learn.microsoft.com/en-us/archive/blogs/ericlippert/… – Konstanz

Eric probably forgot to mention two more kinds of immutability. Conventional immutability: you append the suffix Immutable to the name of the array, and hope that the caller will get the memo. Remarked immutability: You write in the <remarks> section that the array will not be changed by the callee, and should not be changed by the caller, otherwise puppies and kittens are going to die. – Kucik

Back to seriousness, Eric talked about kinds of immutability, not degrees of immutability. But now that I am thinking of it, it makes some sense to talk about weaker and stronger guarantees about immutability. A collection that's passed through an obfuscator is probably more immutable than an unobfuscated collection, because it's harder to mutate it through reflection. And a collection contained in a machine covered by a thick lead shield is more immutable than a collection in my PC, because it's harder to get mutated by high energy cosmic rays. – Kucik

Answer 7

Do you need an ImmutableArray<T> or is an IReadOnlyList<T> enough? If its the latter, you can always implement a very lightweight array wrapper that meets your needs:

public class ImmutableArrayWrapper<T>: IReadOnlyList<T>
{
     public static ImmutableArrayWrapper<T> Wrap(T[] array)
         => new ImmutableArrayWrapper(array);

    private readonly T[] innerArray;

    private ImmutableArrayWrapper(T[] arr) {
         if (arr == null)
             throw new ArgumentNullException();

         innerArray = arr; }

    public int Count => innerArray.Count();
    public T this[int index] => innerArray[index];

    //IEnumerable<T>...
}

And now you can pass the wrapper to your client safely.

Paring

I would advise using a struct like ImmutableArray, as that means it can have zero overhead compared to an array – Slocum

@YairHalberstadt The problem using an ImmutableArray is that Create copies the array contents; thats the overhead the OP wants to avoid. – Paring

I am the op ;-). I meant use a struct instead of a class, like immutable array does – Slocum

@YairHalberstadt lol, sorry. Well, if using a struct is a must performance wise then this solution won't do; changing the wrapper to a struct doesn't help if you are using IReadOnlyListz<T> references. – Paring

Answer 8

 private static readonly ImmutableArray<Key> FinisherKeys = new[]
 {
     Key.Down,
     Key.Return,
     Key.Enter,
 }.ToImmutableArray();

or

  private static readonly ImmutableArray<Key> FinisherKeys = [
            ..new[]
                {
                    Key.Down,
                    Key.Return,
                    Key.Enter,
                },
        ];

Hooge

Thank you for your interest in contributing to the Stack Overflow community. This question already has a few answers—including one that has been validated by the community. Are you certain your approach hasn’t been given previously? If so, it would be useful to explain how your approach is different, under what circumstances your approach might be preferred, and/or why you think the previous answers aren’t sufficient. Can you kindly edit your answer to offer an explanation? – Humberto