passing float pointer as IntPtr (pinvoke)

Question

Ok I have a DLL function declared as:

[DllImport(mDllName, EntryPoint = "SetParam")]
public static extern bool setParam(string param_name, ref IntPtr param_value);

This function takes many different params i.e in C++ this is how you would use it.

int i=2;
setParam("width", &i);

float k=2.5f;
setParam("factor", &f);

So I am trying to declare a C# functions to call this DLL api, I have got one working for the pointer to integer case:

public static void setWidth(int width)
{
    IntPtr w = new IntPtr(width);
    setParam("width", ref w);
}

But I cannot figure out how to do the second one where I pass a pointer to a float as IntPtr. Any ideas?

public static void setFactor(float f)
{
    IntPtr w = new IntPtr(f); // WHAT GOES HERE??
    setParam("factor", ref w);
}

Answer 1

Unless there's too many combinations, I'd say the best way is to simply have multiple DllImports for the various argument types. For example:

[DllImport(mDllName, EntryPoint = "SetParam")]
public static extern bool setParamInt32(string param_name, ref int param_value);

[DllImport(mDllName, EntryPoint = "SetParam")]
public static extern bool setParamSingle(string param_name, ref float param_value); 

You can then call them properly as

var intVal = 42;
setParamInt32("param", ref intVal);

var floatVal = 42.0f;
setParamSingle("param", ref floatVal);

Using ref IntPtr is wrong in either case - the only reason it works at all is that in 32-bit applications, IntPtr is a 32-bit integer internally. However, it's supposed to be a pointer. A proper use would be something like this:

[DllImport(mDllName, EntryPoint = "SetParam")]
public static extern bool setParam(string param_name, IntPtr param_value); 

Note that the ref isn't there - IntPtr is already an indirection.

To call this, you'll need to allocate some memory, and get a pointer to that - or, use a GCHandle to refer directly to a managed object:

var intValue = 42;
var handle = GCHandle.Alloc(intValue, GCHandleType.Pinned);
setParam("param", handle.AddrOfPinnedObject());

Make sure to dispose of the managed handle properly, of course - pinned handles are a huge pain for the GC.

Manually copying the data to unmanaged memory and back also isn't exactly hard:

var ptr = Marshal.AllocCoTaskMem(sizeof(int));

try
{ 
  Marshal.WriteInt32(ptr, 42);

  setParam("param", ptr);

  // If you need to read the value back:
  var result = Marshal.ReadInt32(ptr);
}
finally
{
  Marshal.FreeCoTaskMem(ptr);
}

But I'd simply stick with automatic marshalling unless you have a very good reason not to.

Answer 2

If you absolutely have to use IntPtr and can't just pass a floatparameter then you can use unsafe coding to pass a float pointer as IntPtr takes a void pointer as a parameter in one of its constructor. However the corresponding unmanaged function must also take a void pointer.

There is two ways you can deal with this, passing void* or passing IntPtr*. I would say passing void* is probably better, since you in general will be doing the same with IntPtr except for that IntPtr will be passed with the pointer instead of the function.

Option 1 - IntPtr

You first have to correct the p/invoke declaration by removing the erroneous ref

[DllImport(mDllName, EntryPoint = "SetParam")]
public static extern bool setParam(string param_name, IntPtr param_value);

You do not pass IntPtr as ref either, just simply pass the instance of your IntPtr

public static unsafe void setFactor(float f)
{
        IntPtr w = new IntPtr(&f);
        setParam("factor", w);
}

Or if you want the unsafe declaration in the body

public static void setFactor(float f)
{
        unsafe
        {
            IntPtr w = new IntPtr(&f);
            setParam("factor", w);
        }
}

Option 2 - void*

[DllImport(mDllName, EntryPoint = "SetParam")]
public unsafe static extern bool setParam(string param_name, void* param_value);

Then you can set it like

public static unsafe void setWidth(int width)
{
    int* w = &width;
    setParam("width", w);
}

And for the float

public static unsafe void setFactor(float f)
{
    float* fptr = &f;
    setParam("factor", fptr);
}

Answer 3

You can theoretically declare different DllImport entries for "safe" automatic marshalling:

[DllImport(mDllName, EntryPoint = "SetParam")]
public static extern bool setParam(string param_name, ref int param_value);

[DllImport(mDllName, EntryPoint = "SetParam")]
public static extern bool setParam(string param_name, ref float param_value);

And use it like:

public static void setFactor(float f)
{
    setParam("factor", ref f);
}

I have done this for other functions using void * as a signature and it works just fine, the ref <value_type> gets correctly passed in as a pointer.

Also, ref IntPtr should be for void ** (you'd use IntPtr for void *, not ref IntPtr)

If you are ok with unsafe, then you can use @Bauss solution

Furthermore, using the constructor IntPtr(int) is giving a location for the pointer, not the value at the location