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.

Get device (joystick) guid with windows multimedia (winmm.dll)

I try to implement interoperating with unmanaged code and c#.
I've decided to use winmm.dll for this.
There is need for get joystick unique guid and identify devise status (connected or not)
After some investigation i believe that founded out function that should to do it (joyGetDevCapsA). But there is not clear what value should be pass as int id parameter
public static class InputControllerInteroperator
{
private const string WINMM_NATIVE_LIBRARY = "winmm.dll";
private const CallingConvention CALLING_CONVENTION = CallingConvention.StdCall;
[DllImport(WINMM_NATIVE_LIBRARY, CallingConvention = CALLING_CONVENTION), SuppressUnmanagedCodeSecurity]
public static extern int joyGetPosEx(int uJoyID, ref JOYINFOEX pji);
[DllImport(WINMM_NATIVE_LIBRARY, CallingConvention = CALLING_CONVENTION), SuppressUnmanagedCodeSecurity]
public static extern int joyGetPos(int uJoyID, ref JOYINFO pji);
[DllImport(WINMM_NATIVE_LIBRARY, CallingConvention = CALLING_CONVENTION), SuppressUnmanagedCodeSecurity]
public static extern int joyGetNumDevs();
[DllImport(WINMM_NATIVE_LIBRARY, CallingConvention = CALLING_CONVENTION, EntryPoint = "joyGetDevCaps"), SuppressUnmanagedCodeSecurity]
public static extern int joyGetDevCapsA(int id, ref JOYCAPS lpCaps, int uSize);
}
There is not lot information about winmm API for C# thought internet, so if someone have experience please share it.
Q: How can be detected attached or not joystick at current moment and get device unique Guid?

According to the #Hans Passant (https://stackoverflow.com/users/17034/hans-passant) comments below question:
There is no guid, there is no connection state. The specific joystick is identified with a simple uint. 0 is the first joystick, 1 is the second, etc.
It works for me

What is the DLL loading behavior when using DllImport[] in C#?

Using the following code as example:
[DllImport("C:\\Users\\Rodrigo\\Desktop\\ds08_asio\\dsproEtherFaceAsio\\x64\\Debug\\dsproEtherFaceAsio.dll")]
public static extern void open_console();
[DllImport("C:\\Users\\Rodrigo\\Desktop\\ds08_asio\\dsproEtherFaceAsio\\x64\\Debug\\dsproEtherFaceAsio.dll")]
public static extern int get_available_interface(int index, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder buffer, int maxSize);
[DllImport("C:\\Users\\Rodrigo\\Desktop\\ds08_asio\\dsproEtherFaceAsio\\x64\\Debug\\dsproEtherFaceAsio.dll")]
public static extern int get_buffer();
[DllImport("C:\\Users\\Rodrigo\\Desktop\\ds08_asio\\dsproEtherFaceAsio\\x64\\Debug\\dsproEtherFaceAsio.dll")]
public static extern int get_channels();
What would be the loading behaviour of the DLL? To be more specific, will each DllImport create one instance of the DLL and export a single function? Or will one instance of the DLL be created and all functions exported?

DLLImport fails to find the DLL file

I have a C# application which needs to import a function from a C++ dll. I use DLLImport to load the function. It works fine in English and Chinese environment, but it always raise 'Module not found' exception in French operating system.
The code snapshot:
[DllImport("abcdef.dll", CallingConvention = CallingConvention.StdCall)]
public static extern string Version();
Note that letters in the name of module have been replaced but the name itself is in the same format and the same length.
And a screenshot:
Any ideas?

I have tried all methods you proposed, however the problem still exists.
Here is an alternative way which could avoid that error. It uses Win32 APIs to load the library and find the address of the function, then invoke it. Demo code follows:
class Caller
{
[DllImport("kernel32.dll")]
private extern static IntPtr LoadLibrary(String path);
[DllImport("kernel32.dll")]
private extern static IntPtr GetProcAddress(IntPtr lib, String funcName);
[DllImport("kernel32.dll")]
private extern static bool FreeLibrary(IntPtr lib);
private IntPtr _hModule;
public Caller(string dllFile)
{
_hModule = LoadLibrary(dllFile);
}
~Caller()
{
FreeLibrary(_hModule);
}
delegate string VersionFun();
int main()
{
Caller caller = new Caller("abcdef.dll");
IntPtr hFun = GetProcAddress(_hModule, "Version");
VersionFun fun = Marshal.GetDelegateForFunctionPointer(hFun, typeof(VersionFun)) as VersionFun;
Console.WriteLine(fun());
return 0;
}
}

DLLImport a variable MFC dll

So I created the following test project:
[DllImportAttribute("TestMFCDLL.dll", CallingConvention = CallingConvention.Cdecl)]
internal static extern int test(int number);
private void button1_Click(object sender, EventArgs e)
{
int x = test(5);
}
Which works fine for my MFC dll that has the function test defined, however what I actually have is many MFC dlls that all share a common entry function and run differently based on my inputs. So basically I have tons of dlls that I cannot know at compile time what the name is, I just know that they have a function similar to how this program is setup, is there a way to import a dll based on run-time knowledge? Simply doing this returns an error:
static string myDLLName = "TestMFCDLL.dll";
[DllImportAttribute(myDLLName, CallingConvention = CallingConvention.Cdecl)]
An attribute argument must be a constant expression, typeof expression
or array creation expression of an attribute parameter type

If you want to dynamically load a DLL and use the functions in the DLL, then you'll need to do a little bit more. First you need to load the DLL dynamically. You can use LoadLibrary and FreeLibrary for that.
[DllImport("kernel32.dll")]
public static extern IntPtr LoadLibrary(string dllName);
[DllImport("kernel32.dll")]
public static extern bool FreeLibrary(IntPtr hModule);
Second you need to get the address of the function in the DLL and call it.
[DllImport("kernel32.dll")]
public static extern IntPtr GetProcAddress(IntPtr hModule, string functionName);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate int Test(int number);
Putting that all together:
IntPtr pLib = LoadLibrary(#"PathToYourDll.DLL");
IntPtr pAddress = GetProcAddress(pLib, "test");
Test test = (Test)Marshal.GetDelegateForFunctionPointer(pAddress, typeof(Test));
int iRresult = test(0);
bool bResult = FreeLibrary(pLib);