Replace `Unsafe.NullRef<T>()` usage

[xtqqczze]

Use ref *(T*)nullinstead of Unsafe.NullRef<T>() to save 3 bytes of IL (sharplab).

Slightly smaller IL size (saves 3 bytes) an most importantly avoids a generic type instantiation. Could also potentially help the JIT in some niche cases, though it should handle NullRef well too given it's an intrinsic now. I'd also say conceptually it seems to me ref *(T*)null makes more sense in that the Unsafe APIs were all added as a workaround for things that could not be done at all in C#. Now that C# can express this, there's no need to use the workaround API anymore. It's the same with Unsafe.SizeOf<T>: now that you can just do sizeof(T) everywhere, there's no need to ever use that either. Same thing for Unsafe.As in some context, now that you can have pointers to managed types 🙂

Like, if hypothetically speaking you could do everything you can do with Unsafe with just C#, you'd never use Unsafe, and for the same reason if C# had always been able to express all of it, Unsafe APIs would've never been added in the first place.

Originally posted by @Sergio0694 in #79589 (comment)

I couldn't figure out the best area label to add to this issue. If you have write-permissions please help me learn by adding exactly one area label.

[tannergooding]

I’m not convinced this is better. It certainly results in smaller IL but it also comes at the cost of being harder to read/reason about in many ways, particularly due to the cast and indirections.

For optimized code we’re already able to see this is an intrinsic and so we can adjust the inlining profitability accordingly. We could likely adjust the IL cost as well if we believed it to have significant impact.

cc. @jkotas

Tagging subscribers to this area: @dotnet/area-system-runtime
See info in area-owners.md if you want to be subscribed.

Issue Details

---

Use ref *(T*)nullinstead of Unsafe.NullRef<T>() to save 3 bytes of IL (sharplab).

Slightly smaller IL size (saves 3 bytes) an most importantly avoids a generic type instantiation. Could also potentially help the JIT in some niche cases, though it should handle NullRef well too given it's an intrinsic now. I'd also say conceptually it seems to me ref *(T*)null makes more sense in that the Unsafe APIs were all added as a workaround for things that could not be done at all in C#. Now that C# can express this, there's no need to use the workaround API anymore. It's the same with Unsafe.SizeOf<T>: now that you can just do sizeof(T) everywhere, there's no need to ever use that either. Same thing for Unsafe.As in some context, now that you can have pointers to managed types 🙂

Like, if hypothetically speaking you could do everything you can do with Unsafe with just C#, you'd never use Unsafe, and for the same reason if C# had always been able to express all of it, Unsafe APIs would've never been added in the first place.

Originally posted by @Sergio0694 in #79589 (comment)

Author:	xtqqczze
Assignees:	-
Labels:	area-System.Runtime, untriaged
Milestone:	-

[jkotas]

I agree with @tannergooding. The savings are very small, not worth the style and readability degradation.

(Also, this would be asymmetric with Unsafe.IsNullRef.)