I am trying to use a third party DLL that wants an int** as one of the parameters to the method. It describes the parameter as the address of the pointer that will point to the memory allocation.
Sorry for any confusion. The parameter is two-way I think. The DLL is for talking to an FPGA board and the method is setting up DMA transfer between the host PC and the PCI board.
DllImport attribute uses the InteropServices of the CLR, which executes the call from managed code to unmanaged code. It also informs the compiler about the location of the implementation of the function used.
Using the extern modifier means that the method is implemented outside the C# code, whereas using the abstract modifier means that the method implementation is not provided in the class. The extern keyword has more limited uses in C# than in C++.
The IntPtr type can be used by languages that support pointers and as a common means of referring to data between languages that do and do not support pointers. IntPtr objects can also be used to hold handles. For example, instances of IntPtr are used extensively in the System. IO.
Most of the P/Invoke API is contained in two namespaces: System and System. Runtime.
Use a by-ref System.IntPtr
.
[DllImport("thirdparty.dll")]
static extern long ThirdPartyFunction(ref IntPtr arg);
long f(int[] array)
{ long retval = 0;
int size = Marshal.SizeOf(typeof(int));
var ptr = IntPtr.Zero;
try
{ ptr = Marshal.AllocHGlobal(size * array.Length);
for (int i= 0; i < array.Length; ++i)
{ IntPtr tmpPtr = new IntPtr(ptr.ToInt64() + (i * size));
Marshal.StructureToPtr(array, tmpPtr, false);
}
retval = ThirdPartyFunction(ref ptr);
}
finally
{ if (ptr != IntPtr.Zero) Marshal.FreeHGlobal(ptr);
}
return retval;
}
You will have to make use of the Marshal class or go unsafe in this case.
It could also just be a pointer to an array, so a ref int[] list
might work.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With