[Request] Permit unmanaged generics on extern functions marked with 'DLLImport'

[Unknown6656]

Background

A few days ago, I had to implement a P/Invoke-call to ioctl(2).
I looked up the function signature in the Linux man pages to see the following:

ioctl(2)

#include <sys/ioctl.h>

int ioctl(int fd, unsigned long request, ...);

Here, the "..." represents the C++-equivalent of a params-array, however, I cannot pass an array for obvious reasons. It was not really an issue for my specific use case, as I used a small C++-wrapper to manage the data transfer to the ioctl function.

However, it got me thinking. What if one wants to pass params-arguments to C++? C++'s variadic functions cannot be easily called from C#, so most people would either allocate some shared buffer/stream or they'd create an unmanaged struct holding all the data.

Request

Permit generic parameters (constrained to unmanaged) to be used in extern function declarations marked with [DllImport]. This could permit users to write:

[DllImport("my_library.dll")]
public static extern int MyMethod<T>(nint size, ref T data) where T : unmanaged;

when e.g. calling the following function in a "safe" manner (meaning that in the code above, I do not need to use unsafe):

extern "C" __declspec(dllexport) int MyMethod(size_t size, void* data) { ... }

I think that at least ref T data, out T data and T* data should be allowed to be used when marked as T : unmanaged.


Whether T data should be permitted, I cannot judge.... I'm not seeing any use cases as the size of T might differ depending on the call (wich is not the case for ref T, out T and T*).

[Unknown6656]

(maybe the 'Backgorund'-section is a bit orthogonal to my request .... I just wanted to share my train of thought.)

[HaloFour]

IIRC __arglist can be used to call unmanaged variadic imports like this. I recall using it on some Win32 API like wsprintf.

[PathogenDavid]

when e.g. calling the following function in a "safe" manner (meaning that in the code above, I do not need to use unsafe):

If this is your motivation, why not just wrap the P/Invoke?

[DllImport("my_library.dll")]
private unsafe static extern int MyMethod(nint size, void* data);
    
public unsafe static int MyMethod<T>(nint size, ref T data)
    where T : unmanaged
{
    fixed (T* dataP = &data)
    {
        return MyMethod(size, dataP);
    }
}

[gfoidl]

@PathogenDavid I don't think this

Unsafe.AsPointer(ref data));

is safe. Yeah, you'll get the pointer, but the GC is still allowed to move data around, as it isn't pinned. Then on the native side you can have an AV or garbage data.

Iif you know data is pinned (e.g. coming from fixed (but then you have the pointer anyway), or from GC.Allocate* (with pinned set)) then this works reliable.

[Unknown6656]

@HaloFour: Damn! I completely forgot about __arglist! I also heard something about it being used for P/Invoke, but it was quite some time ago....

@PathogenDavid You're right of course - wrapping it would be the easiest, most straight-forward solution. I just wanted an excuse to lift this restriction of not being able to use generics on [DllImport] 😉 ... espcially since we now have the unmanaged-constraint.

[PathogenDavid]

@PathogenDavid I don't think this [...] is safe.

You're right, that was a dangerous brain fart on my part. Fixed the example.