Develop Reference

C# DllImport - Call a function that returns an struct

I am working in C# and I need to call a function in a C++ dll library. This function returns a struct but I can´t get anything.
This is the function I need to call and the struct that returns in C++ library:
ATHENA_API _DEVICE_INFO* __stdcall GetDeviceInfoKeepConnection(_DEVICE_INFO* pDeviceInfo);
typedef struct TD_DEVICE_INFO{
TCHAR chDeviceName[256];
int nCommPort;
int nECGPos;
int nNumberOfChannel;
int nESUType;
int nTymestampType;
int nDeviceHandle;
TCHAR chDeviceID[260];
}_DEVICE_INFO;
This is my C# code trying to call the function:
[DllImport(#"\BAlertSDK\ABM_Athena.dll")]
static extern _DEVICE_INFO GetDeviceInfoKeepConnection(_DEVICE_INFO deviceInfo);
[StructLayout(LayoutKind.Sequential)]
struct _DEVICE_INFO
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string chDeviceName;
public int nCommPort;
public int nECGPos;
public int nNumberOfChannel;
public int nESUType;
public int nTymestampType;
public int nDeviceHandle;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
public string chDeviceID;
}
void Test_Click()
{
_DEVICE_INFO d = new _DEVICE_INFO();
_DEVICE_INFO deviceInfo = GetDeviceInfoKeepConnection(d);
}
The only I can get is an empty _DEVICE_INFO object. I think my problem is that I am not defining correctly the DEVICE INFO struct.
I have never worked with dll´s to this level. Can you help me?
Thanks in advance.

Thanks to all!! The problem has solved with this:
Parameter pass by reference and struct charset Unicode.

It seems that the function GetDeviceInfoKeepConnection returns a pointer to _DEVICE_INFO struct. So, in your C# code, you need to change the definition of the function to:
[DllImport(#"\BAlertSDK\ABM_Athena.dll")]
static extern IntPtr GetDeviceInfoKeepConnection(IntPtr deviceInfo);
And then you can access the struct data like this:
void Test_Click()
{
_DEVICE_INFO d = new _DEVICE_INFO();
IntPtr pDeviceInfo = Marshal.AllocHGlobal(Marshal.SizeOf(d));
Marshal.StructureToPtr(d, pDeviceInfo, false);
IntPtr deviceInfo = GetDeviceInfoKeepConnection(pDeviceInfo);
_DEVICE_INFO result = (_DEVICE_INFO)Marshal.PtrToStructure(deviceInfo, typeof(_DEVICE_INFO));
Marshal.FreeHGlobal(pDeviceInfo);
}
Note that, to ensure that the memory is cleaned up after use, you should use the Marshal.FreeHGlobal method to free the memory that was allocated by Marshal.AllocHGlobal.

Pointer declaration in C#

This may be a stupid beginners question but I do not get it. I have a DLL which declares a function
int get_state(const unsigned char n,unsigned int *state)
What is the related C# import statement? Is
public static extern int get_card(byte n,ref uint state);
[DllImport(#"my.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
correct?
And when using this function, how do I have to call get_card() in order to get the data out of the parameter returned in state?
Thanks!

Well, DllImportAttribute must be put before the method it describes:
public static class MyClass {
...
// Since you don't use String, StringBuilder etc.
// CharSet = CharSet.Ansi is redundant and can be omitted
[DllImport(#"my.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int get_card(byte n, ref uint state);
...
}
Having get_card method declared, you can use it as usual, as any other method (and .Net will marshall the arguments):
...
byte n = 123;
uint state = 456;
int result = MyClass.get_card(n, ref state);
...

Marshalling an integer pointer inside a structure as a callback

I have a C structure used for callback that I need to marshall to C# .NET:
struct CTMDeviceInfo {
enum CTMDeviceType eDeviceType;
char * szDeviceModel;
char * szDeviceSubModel;
int32_t * piDeviceID;
};
This is my C# version:
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CTMDeviceInfo
{
public CTMDeviceType deviceType;
[MarshalAs(UnmanagedType.LPStr)]
public string deviceModel;
[MarshalAs(UnmanagedType.LPStr)]
public string deviceSubModel;
public IntPtr deviceId;
};
Which is used inside another structure:
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CTMDeviceError
{
public CTMDeviceInfo deviceInfo;
[MarshalAs(UnmanagedType.I4)]
public Int32 resultCode;
[MarshalAs(UnmanagedType.I4)]
public Int32 extendedResultCode;
public IntPtr denomination;
public IntPtr changeDue;
};
My problem is that the "IntPtr deviceId" does not consistently return the correct value every time a callback was made.
I was expecting an integer value of 5, 15 or 16 but it keeps returning random values like 106, 865412, 652272, etc.
I don't know what I did wrong. What I did though is to prevent the callback in my managed code to be garbage collected using GCHandle.
Here is the sequence on how I did it:
From my unmanaged code I have this CDECL callback method:
void ctm_add_device_error_event_handler(CTMDeviceErrorCallback);
typedef void (CTMDeviceErrorCallback) (struct CTMEventInfo, struct CTMDeviceError );
This is my managed code:
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void OnDeviceErrorCallBack(CTMEventInfo evtInfo, CTMDeviceError deviceError);
[DllImport("libctmclient-0.dll", EntryPoint = "ctm_add_device_error_event_handler", CallingConvention = CallingConvention.Cdecl)]
public static extern void AddDeviceErrorEventHandler([MarshalAs(UnmanagedType.FunctionPtr)] OnDeviceErrorCallBack deviceErrorCallBack);
OnDeviceErrorCallBack deviceErrorCallback;
GCHandle deviceErrorCallbackGCHandle;
deviceErrorCallback = new OnDeviceErrorCallBack(OnDeviceError);
deviceErrorCallbackGCHandle = GCHandle.Alloc(deviceErrorCallback);
AddDeviceErrorEventHandler(deviceErrorCallback);
And this is where the callback is handled:
public void OnDeviceError(CTMEventInfo evtInfo, CTMDeviceError deviceError)
{
int nDeviceId = Marshal.ReadInt32(deviceError.deviceInfo.deviceId);
}
I tried to use unsafe to use pointers directly but the issue is still the same.
public unsafe int *deviceId; //instead of IntPtr
int nDeviceId = 0;
unsafe
{
nDeviceId = *(deviceError.deviceInfo.deviceId);
}
I'm sure that my unmanaged code returned the correct value because I have logs but when it reached in my managed code, somehow another value was returned.
It's like it is reading on a different reference or something.
Hope somewhat could help me because I am stuck for a while now.
Thanks!

Use following c# structure. You can get the two string from the pointer later in the code. :
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CTMDeviceInfo
{
public CTMDeviceType deviceType;
public IntPtr deviceModel;
public IntPtr deviceSubModel;
public IntPtr deviceId;
};

pinvoke get data from struct in c

I am using pinvoke in a project I am building.
I need to get data from a function in C, the function gets pointer to a struct.
In my c# I did a class with the appropriate attribute(layountkind.sequntial).
Before the function I do:
mystruct str=new mystruct();
str.Data=new byte[14];
func(str);
I fill the struct in the function but when it exit the function the instance of the class doesn't have the values i filled in c,i check the content of the pointer before i exit the c function and it has the right values.
Below is the prototype of the function:
[DllImport("mydll.dll", CallingConvention=CallingConvention.Cdecl)]
void func([MarshalAs(UnmanagedType.LPStruct)] mystruct str);
My struct in C#:
[StructLayout(LayoutKind.Sequential)]
public class mystruct
{
public ushort familiy;
[MatshalAs(UnmanagedType.ByValArray,SizeConst=14)]
public byte [] data;
}
function and struct in C:
struct sockaddr{
unsigned short familiy;
char data [14];
};
void func(struct sockaddr *info)
{
int i;
char buffer[100]
recvfrom(sockfd,buffer,0,info,&i);//assume i have a global varible sockfd and it is an open socket
}
How can i fix my problem?

The p/invoke declaration is incorrect. The default marshalling is In only. But you need Out marshalling. Otherwise the marshaller won't attempt to marshal the data set by the unmanaged function back to the managed class.
So you can fix the problem by declaring the function like this:
[DllImport("mydll.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void func([Out] mystruct str);
Personally I think that it would be more idiomatic to use a C# struct. I'd declare it like this:
[StructLayout(LayoutKind.Sequential)]
public struct mystruct
{
public ushort family;
[MarshalAs(UnmanagedType.ByValArray, SizeConst=14)]
public byte[] data;
}
And then the function becomes:
[DllImport(dllname, CallingConvention = CallingConvention.Cdecl)]
static extern void func(out mystruct str);
And the call is simply:
mystruct str;
func(out str);

Issue Marshalling C# Structure to call C .DLL

I'm having difficulty trying to marshal a structure I've defined in a C# program that is required for calling an unmanaged C .DLL file I do not have access to the source code for. A sample unmanaged C program C program can call this .DLL with no issue. The problem structure is fa_keylist below. There are multiple sub structures contained in the structure I am having issues with:
From the C header file:
struct fa_keypart {
short kp_start;
short kp_leng;
long kp_flags;
};
struct fa_keydesc {
long k_flags;
long k_nparts;
struct fa_keypart k_part [FA_NPARTS];
};
struct fa_keylist {
long kl_nkeys;
char kl_reserve[4];
struct fa_keydesc *kl_key [FA_NKEYS];
}
In C#, I have this defined as:
[StructLayout(LayoutKind.Sequential)]
public struct fa_keypart
{
public Int16 kp_start;
public Int16 kp_leng;
public Int32 kp_flags;
}
[StructLayout(LayoutKind.Sequential)]
public struct fa_keydesc
{
public Int32 k_flags;
public Int32 k_nparts;
[MarshalAs(UnmanagedType.ByValArray)]
public fa_keypart[] kparts;
};
[StructLayout(LayoutKind.Sequential)]
public struct fa_keylist
{
public Int32 kl_nkeys;
public UInt32 kl_reserve;
[MarshalAs(UnmanagedType.ByValArray)]
public fa_keydesc[] kl_keys;
}
The DLLIMPORT signature for the actual call is defined as:
[STAThread]
[DllImport("F4AGFCFA.dll", EntryPoint = "cobfa_open", CallingConvention = CallingConvention.StdCall)]
public static extern Int32 cobfa_open(
string fileName,
Int32 openFlags,
ref fa_keylist keyList,
Int32 recordLength);
The call to the function is coded as:
handle = cobfa_open(filename, fileFlags, ref keyList, 80);
I've tried a number of different Marshalling options by the way. The current error I receive is an Access Violation (Attempt to read or write protected memory).
Any suggestions would be greatly appreciated.

You need to specify the size for the arrays. Assuming that FA_NPARTS in C is 128, you could do the following:
[StructLayout(LayoutKind.Sequential)]
public struct fa_keydesc
{
public Int32 k_flags;
public Int32 k_nparts;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
public fa_keypart[] kparts;
};
UnmanagedType.ByValArray only works with SizeConst set as well.