Chapter 155: Interoperability

Section 155.1: Import function from unmanaged C++ DLL

Here is an example of how to import a function that is defined in an unmanaged C++ DLL. In the C++ source code for "myDLL.dll", the function add is defined:

extern "C" __declspec(dllexport) int __stdcall add(int a, int b)

{

return a + b;

}

Then it can be included into a C# program as follows:

class Program

{

//This line will import the C++ method.

//The name specified in the DllImport attribute must be the DLL name.

//The names of parameters are unimportant, but the types must be correct.

[DllImport("myDLL.dll")]

private static extern int add(int left, int right);

static void Main(string[] args)

{

//The extern method can be called just as any other C# method.

Console.WriteLine(add(1, 2));

}

}

See Calling conventions and C++ name mangling for explanations about why extern "C" and __stdcall are necessary.

Finding the dynamic library

When the extern method is first invoked the C# program will search for and load the appropriate DLL. For more information about where is searched to find the DLL, and how you can influence the search locations see this stackoverflow question.

Section 155.2: Calling conventions

There're several conventions of calling functions, specifying who (caller or callee) pops arguments from the stack, how arguments are passed and in what order. C++ uses Cdecl calling convention by default, but C# expects StdCall, which is usually used by Windows API. You need to change one or the other:

Change calling convention to StdCall in C++:

extern "C" __declspec(dllexport) int __stdcall add(int a, int b)

[DllImport("myDLL.dll")]

Or, change calling convention to Cdecl in C#:

extern "C" __declspec(dllexport) int /*__cdecl*/ add(int a, int b) [DllImport("myDLL.dll", CallingConvention = CallingConvention.Cdecl)]

conditions.

The pointer returned by GetProcAddress() can be casted into a delegate using

Marshal.GetDelegateForFunctionPointer().

The following code sample demonstrates this with the myDLL.dll from the previous examples:

class Program

{

//import necessary API as shown in other examples

[DllImport("kernel32.dll", SetLastError = true)] public static extern IntPtr LoadLibrary(string lib); [DllImport("kernel32.dll", SetLastError = true)] public static extern void FreeLibrary(IntPtr module); [DllImport("kernel32.dll", SetLastError = true)]

public static extern IntPtr GetProcAddress(IntPtr module, string proc);

//declare a delegate with the required signature

private delegate int AddDelegate(int a, int b);

private static void Main()

{

// load the dll

IntPtr module = LoadLibrary("myDLL.dll"); if (module == IntPtr.Zero) // error handling

{

Console.WriteLine($"Could not load library: {Marshal.GetLastWin32Error()}"); return;

}

// get a "pointer" to the method

IntPtr method = GetProcAddress(module, "add"); if (method == IntPtr.Zero) // error handling

{

Console.WriteLine($"Could not load method: {Marshal.GetLastWin32Error()}"); FreeLibrary(module); // unload library

return;

}

// convert "pointer" to delegate

AddDelegate add = (AddDelegate)Marshal.GetDelegateForFunctionPointer(method, typeof(AddDelegate));

// use function

int result = add(750, 300);

// unload library

FreeLibrary(module);

}

}

Section 155.5: Reading structures with Marshal

Marshal class contains a function named PtrToStructure, this function gives us the ability of reading structures by an unmanaged pointer.

PtrToStructure function got many overloads, but they all have the same intention.

Generic PtrToStructure:

public static T PtrToStructure<T>(IntPtr ptr);

T - structure type.

ptr - A pointer to an unmanaged block of memory.

Example:

NATIVE_STRUCT result = Marshal.PtrToStructure<NATIVE_STRUCT>(ptr);

If you dealing with managed objects while reading native structures, don't forget to pin your object :)

T Read<T>(byte[] buffer)

{

T result = default(T);

var gch = GCHandle.Alloc(buffer, GCHandleType.Pinned);

try

{

result = Marshal.PtrToStructure<T>(gch.AddrOfPinnedObject());

}

finally

{

gch.Free();

}

return result;

}

Section 155.6: Dealing with Win32 Errors

When using interop methods, you can use GetLastError API to get additional information on you API calls.

DllImport Attribute SetLastError Attribute

SetLastError=true

Indicates that the callee will call SetLastError (Win32 API function).

SetLastError=false

Indicates that the callee will not call SetLastError (Win32 API function), therefore you will not get an error information.

When SetLastError isn't set, it is set to false (Default value).

You can obtain the error code using Marshal.GetLastWin32Error Method:

Example:

[DllImport("kernel32.dll", SetLastError=true)]

public static extern IntPtr OpenMutex(uint access, bool handle, string lpName);

If you trying to open mutex which does not exist, GetLastError will return ERROR_FILE_NOT_FOUND.

var lastErrorCode = Marshal.GetLastWin32Error();