My C declarations are as follows:

int myData(uint myHandle, tchar *dataName, long *Time, uint *maxData, DATASTRUCT **data);

typedef struct {

  byte Rel;

  __int64 Time;

  char Validated;

  unsigned char Data[1];


My C# declarations are as follows:

[DllImport("myData.dll", EntryPoint = "myData")]

public static extern int myData(uint myHandle, [MarshalAs(UnmanagedType.LPTStr)] string dataName, out long Time, out uint maxData, ref DATASTRUCT[] data);

[StructLayout(LayoutKind.Sequential, Pack = 1)]

public struct DATASTRUCT


    public sbyte Rel;

    public long Time;

    public byte Validated;

    public double Data;


I then call the managed function as follows:

string dataToShow = "description";

long Time;

uint maxData; // How many structs will be returned, i.e. how much data is available

uint myHandle = 1;

DATASTRUCT[] dataInformation = new DATASTRUCT[3]; // doesn't matter what I specify as the array size?

myData(myHandle, dataToShow, out Time, out maxData, ref dataInformation);

Upon execution the above function will return successfully with only one structure even though there are 3 to return. Why is this so?

Additional information; I have tried passing the pointer to a pointer of an array of structs the following ways:

- ref DATASTRUCT[] data; // Works but only returns one struct

- [Out, MarshalAs(UnmanagedType.LPArray)] DATASTRUCT[] data; // returns the number of defined structs with garbage

As I understand it I might need to do some manual marshalling using IntPtr, I do not know how to implement this however, so any advice would be appreciated.

Best Answer:

Okay, it seems as though your native library does the allocation, so really all you need to do is provide a pointer through which you can access the allocated data.

Change your API definition to (note, I changed the maxData param to uint, long is 64 bits in .NET and 32 bits in native.

[DllImportAttribute("myData.dll", EntryPoint = "myData")]

public static extern int myData(uint myHandle, [MarshalAs(UnmanagedType.LPTStr)] string dataName, out uint Time, out uint maxData, out IntPtr pData);

Off the top of my head I can't quite remember if you need the out keyword for the final parameter, but I think so.

Then, call myData:

uint nAllocs = 0, time = 0;

IntPtr pAllocs = IntPtr.Zero;

myData(1, "description", out time, out nAllocs, out pAllocs);

Now, pAllocs should point to unmanaged memory, to marshal these into managed memory isn't too difficult:

[StructLayoutAttribute(LayoutKind.Sequential, Pack = 1)]

public struct DATASTRUCT


    public byte Rel;

    public long Time;

    public byte Validated;

    public IntPtr Data; //pointer to unmanaged string.


int szStruct = Marshal.SizeOf(typeof(DATASTRUCT));

DATASTRUCT[] localStructs = new DATASTRUCT[nAllocs];

for(uint i = 0; i < nallocs; i++)

    localStructs[i] = (DATASTRUCT)Marshal.PtrToStructure(new IntPtr(pAllocs.ToInt32() + (szStruct * i)), typeof(DATASTRUCT));

And now you should have an array of local structs.

A point to note You may need to set your project to compile as x86, to standardize the size of an IntPtr to 4 bytes (DWORD) instead of AnyCPU's default 8.

Copyright © 2011 Dowemo All rights reserved.    Creative Commons   AboutUs