API To convert from ref T* to ref nint

[Tacodiva]

Currently as far as I know, there is no way to convert from a ref T* to a ref nint. This can be an important operation if you want to do atomic operations or volatile reads/writes on a ref T*, because the methods in Interlocked and Volatile expected a ref nint.

This conversion can be done like this:

    public static unsafe ref nint AsNIntRef<T>(ref T* reference) where T : unmanaged {
        fixed (void* pRef = &reference) return ref Unsafe.AsRef<nint>(pRef);
    }

However this is not non-obvious and feels kinda hacky. I think there should be a method like this build into the runtime. I do not know where this method should go (maybe Unsafe?) or what it should be called, hence I have not made a proper API proposal.

[paulbartrum]

I'm confused. A ref is essentially a pointer, just one tracked by the garbage collector. So you effectively have a pointer to a pointer, and you change that to a pointer to a native-integer by pinning the pointer variable? I've written tons of unsafe code and I've never had the need to do what you're suggesting.

[huoyaoyuan]

Pinning is the syntax to convert a ref to pointer. Unsafe.AsPointer is unavailable because T* can't be used as a type parameter.

[paulbartrum]

Yeah, I know what pinning does, it just didn't seem like you would need to pin given that you start from a ref and go to a ref. But I didn't consider the inability to pass a pointer as a generic type argument. Maybe write a comment explaining what you need in this issue? #13627

[Tacodiva]

You're right, you shouldn't need to pin anything, I just found that it's a hacky way to get around the generic restriction and do the conversion.

[hamarb123]

I personally have a helper in IL to do this for this exact usage (except mine is based on nuint rather than nint).

Another option these days (.NET 9+ (for .NET 7/8, you can just replace the BitCast with some pointer tricks)) would be:

ref struct PtrRef<T>(ref T* reference)
{
    public ref T* reference = ref reference;
}

ref struct NIntRef
{
    public ref nint reference;
}

return ref Unsafe.BitCast<PtrRef<T>, NIntRef>(new(ref reference)).reference;

which can be fully written from C#, but relies on UB (in particular, assuming that the layouts are going to be what you'd expect, etc.), but I think it's fine for now with the current runtimes/GCs (I wouldn't really recommend this solution due to the UB, but it is probably practically fine for now, and you could replace it with an IL implementation later, so it's future proof in the sense that you can always fix it later if you need to).

Note that your API was proposed previously here.

[Tacodiva]

Yeah that's a nice way to do it too, I hadn't thought of that. Seems both the fixed way and this compile to the same x86 so it's just whichever you'd prefer.

[hamarb123]

They do not have the same assembly, e.g., here's the optimised x64 asm for both: https://godbolt.org/z/Tvrx36Gsq.

The fixed statement causes a spill, whereas the JIT can see through what my code is doing (you'd probably still want AggressiveInlining on the helper though, to ensure the JIT emits what you want).
Here's the arm64 and x86 codegen too if you're interested, which also both differ.

[Tacodiva]

You're right I was mistaken. Thanks for the correction

[rickbrew]

I ran into this exact same problem awhile ago, and I created a nuget package for it: https://github.com/rickbrew/PointerToolkit

So you could use that for now if you'd like until/if we get something built-in to the runtime. @hamarb123 's solution might be simpler though, my package predates things like ref structs with ref fields.

int value = ...;
int* pValue = &value;
ref int* refpValue = ref pValue;
ref nint refAsNint = ref UnsafePtr.As<int, nint>(ref refpValue);