Proposal: allow pinning a generic ref T/T[] variable as either T* or void*

[Sergio0694]

C# currently allow to declare fixed void* pointers from basically any struct type (in a non-generic method), as well as typed pointers to struct types, but it isn't possible to get either a T* pointer nor a void* pointer from a ref T or T[] variable, even when T : struct. So, currently:

ref int r = ...
fixed (void* pr = &r) { } // Valid
fixed (int* pr = &r) { } // Valid
int[] arr = ...
fixed (int* p = arr) { } // Valid

But something like this will just fail:

public static void Foo<T>(T[] arr, ref T r) where T : struct
{
    fixed (T* p = arr) { } // Doesn't compile
    fixed (void* p = &r) { } // Doesn't compile
    fixed (T* p = &r) { } // Doesn't compile
}

It'd be great to have a way to be able to work with pointers on arrays of generic structs, with either one of these solutions:

• Allow fixed T* pointers when inside an unsafe block
• Allow fixed void* pointers from ref T/T[] variables when inside an unsafe block

I'm aware that the first two would probably need changes to the C# compiler, and since they're not supported right now I assume that's on purpose, but it was worth asking.

Note:

I'm aware it's now possible to get a pinned void* pointer from a ref T value like this:

ref T value = ...
fixed (void* p = &Unsafe.AsRef<T, byte>(ref value))
{
    // p is now fixed
}

But still, being able to convert a ref T with the & operator directly to either void* or T* would be better. Specifically, having a T* pointer would make pointer operations way easier, since the bytes offset would be automatically handled when moving the pointer (as the size of T is known anyways, as it's just a struct).

Thanks for your time! 😄

[ufcpp]

#187
#1100

[IS4Code]

I think extending the fixed statement to both pointers and refs (or even object references) to simply pin them (without unsafe) would be better, since that not only nicely follows the path of extending the usability of references, but also removes the need for subsequent pinning:

ref Struct r1 = ...;
fixed(ref Struct r2 = ref r1) //pinned Struct&
{
	int* ptr = &r2.Field; //"fixed" not needed since the object is already pinned
}

Class o1 = ...;
fixed(Class o2 = o1) //pinned Class
{
	int* ptr = &o2.Field;
}

//maybe even these
string s = ...;
fixed(ref char rc = s)
//or
fixed(TypedReference tr = __makeref(...))

Generic pointers would require the type to be blittable (which needs implementing another feature), but this is not such a heavy change.