Solving One of the Biggest Array Issues in C# 

Unsafe (the class), unsafe (the keyword), P/Invoke, and other topics relating to marshalling and manual memory management, is always good fun. For most people, using these is rarely if ever necessary (especially now that we have the Memory and Span structs), but they're a great learning opportunity that can lead to a much deeper understanding of what actually makes .NET tick.

Please do a video on ConfigureAwait. Thanks

It's interesting with ImmutableArray, but it causes potential issues if somebody without these knowledge or by mistake use add or remove method, which creates a whole new array. I think IReadOnlyList and IReadOnlyCollection would be better which dont provide add or remove method.

Why would you create an array just to cast it to immutable array? Why not ToImmutableArray directly from the enumerable? What about ImmutableArray.Builder?

OFC.. I would really like that you create a (possible longer) video on unsafe :D

I normally return Read-only Memory or ReadOnlySpan to handle these types. The fact that I'm able to re-retrieve a non Read-only version is a bit sus. The unsafe option is also a possibility for avoiding allocations, not sure if i see any real difference except for that the new Marshalling methods make it even easier to get the mutable array back.

Love the polite frankness at 0:09 - "If you've never used immutable array, then... I'm a bit about that" XD

Most of the time, IReadOnlyList is the right type for the right job, not ImmutableArray. Btw, several years ago we rewrote some pieces of the application to use Immutable* types. Later, after profiling, we rewrote them back to Dictionary/HashSet/List+IReadOnly* because of poor access time (log vs const) and memory cost (a tree obviously consumes more memory than a hash table, plus worse localization leads to CPU cache misses, but that's more in theory than in practice), both of which were important for the app. Immutable arrays are an exception here, because they are optimal by both space and time (even better than IReadOnlyList as interface calls are heavier, with the v-table linear search unless I'm mistaking about that). However, ImmutableArray has one functional downside when compared to IReadOnlyList: it implements ICollection and IList which violates the Liskov substitution principle, so good luck calling `void Add(T)`

I have encounter that issue several times and always wanted a immutable array that just point to the backing array, so really thanks for sharing that ;-) I didn´t knew Unsafe.As() either... i really need to look into this, because i like unsafe stuff ^^

Honestly, i think the problem is a different one if your need to use this. If your application requieres you to access the backing field of the immutable collection, you shouldnt have used an immutable collection in the first place. Also, if your application requieres a fast immutable collection access without reallocation, i think you should make that clear using the api interface, using the AsReadOnly methods.

I believe quite a few libraries use the ToImmutableArray stuff to generate things once and some use it for exactly the purpose of ensuring the internal array doesn't mutate. I would love to have a clean immutable or readonly implementation specifically for initalizing (avoiding the creation of the first mutable array) so we don't have to resort to unsafe or Unsafe calls... I suppose in some cases it may just be worth forcing a breaking change in favour of ReadOnlyList, but sometimes that's just not possible or simply the wrong approach...

All right. I'm definitely gonna need that video on Unsafe. I failed at converting a ReadOnlySpan to ReadOnlyMemory without new allocation 2 times now

Good stuff I can see it being used in cases where a method creates and fills an array dynamically but returns immutable version of it in the end and discards the original for zero additional cost.

I just noticed the background image of your logging course 😂

So is it quicker to loop over immutable arrays compared to normal arrays?

Yeah.. I've seen a LOT of times people over abusing lists (use them for every type of collection)..

Please make a video about unsafe it seems very fun

nice! i thought this would be about collection literals, pleasantly surprised

I'm surprised that frozen collections weren't mentioned in the video

A new Rider EAP with AI integration. We need a video for this!

Honestly, what is the point of the ImmutableArray? Why not just IReadOnlyList? Well, you can cast back, but there is also a way to manipulate the ImmutableArray. Or what speaks against ReadOnlyMemory?

It was very helpful information. Thank you so much.

What if I use users[0] = myVar? Does it create a new array for that or just replace first item with a new value?

Interesting stuff, definitely useful for some of my projects.

I don't understand the point of this, you can just pass around an IReadOnlyList instead. Arrays implement IReadOnlyList. Considering you have to be careful to not change the backing array/list anyway with both approaches.

I don't subscribe to this, to me this is like an extra pair of wheels on the bike of programmers who are bad And if I'm saying "ToImmutableArray" and this makes a whole copy, then it's not very different from handing back a modifiable copy array which the user function may need to alter anyways in it's own processing And besides, almost everything in OOP is references and I really doubt the "immutable" array makes the underlying objects any immutable, it's still shared state anyways, still requires common sense from the programmers writing the lib and user code

It's worth noting that this only works because ImmutableArray is a struct. (An object reference and "a struct with an object reference" have the same memory representation)

Does this do the same thing as using reflection to call the internal constructor? I suppose the advantage to that is not relying on non-supported means which Microsoft could break without notice.

Since It is so many comment regarding the IReadonlyList... instead of an ImmutableArray I have a feeling we will get a post about those in a near time :)

If the "ImmutableCollectionsMarshal" actually calls the internal constructor, how does it manage to not allocate any byte?

I have found that more often than not the exact requirement is not to map the dto from a single object, but actually from multiple. More often than not it's best to keep the dtos as the API for your domain logic (your domain logic digests a dto and then outputs another one). And this also means that your dtos should be part of your domain.

I feel like it should be a different struct/class that is a wrapper around the array like a ReadOnlyArray or something like that. Allowing 'hacks' like this seems to break the intention.

More unsafe stuff🎉

So, how is it actually any more immutable than before if you can just get the backing array anyways? Or is it mostly just for the convenience it offers? I've never used ImmutableArray, but what benefits does it provide over exposing something like an IReadOnlyCollection?

Hello Nick, thanks for the video. I wanted to ask how you can access the method implementation of the dotnet framework through your IDE ? Is it a plugin or it's supported out of the box. Also is it supported in Visual Studio

Can’t we return ReadOnlySpan for that purpose? Is there any difference?

I crashed programs so many times using unsafe that's how you know is fun 😂 I feel weird those marshal methods are not marked as unsafe

feels like ReadOnlyArray - but I'll take it!

I think we can also use Array.AsReadOnly(_users). It uses 24 bytes for 10,000 iterations. It's slower - 2.4 ns vs. 0.0082 ns on the Smart() method.

And as always, keep coding unsafely

Haha, “tl;dw” 😂

Never seen any practical application of ImmutableArray for 7 years, a bit of HashSets here, a couple Queues there, but ImmutableArray is a bit confusing collection

the only valid array type is T* where T : unmanaged

Why do we use properties with public get set instead of just a public field? It seems like a completely superfluous wrapper

:o

So you have an immutableArray, you copy into a mutable Array and you have the same problem.

I think you had to choose c++, you spend a lot of time on a lower level optimizations and hacks with C#.

🌸 Promo'SM

ImmutableCollectionMarshal.AsArray looks the best way ever to shoot yourself in the foot.

My method isn't quite as fast as with Unsafe or ImmutableCollectionsMarshal trickery, but it is quite fast compared to AsImmutable: ImmutableArray.Empty.AddRange(_users!); About a 1000 times as fast and doesn't allocate memory (speed is constant so 100 or 10_000 items is similar). And it's totally safe! I swear!

I have never encountered this issue, because IReadOnlyList exists :)