You cannot pass a C++ std::string across an interop boundary. You cannot create one of those in your C# code. So your code can never work. You need to use interop friendly types at the interop boundary. For instance, null-terminated arrays of characters. That works well when you allocate and deallocate the memory in the … Read more
It’s a little old thread, but I recently made excessive performance tests with marshaling in C#. I need to unmarshal lots of data from a serial port over many days. It was important to me to have no memory leaks (because the smallest leak will get significant after a couple of million calls) and I … Read more
Have you take a look at C++/CLI? Let me give a very short example. Here is the source file from a Visual C++ -> CLR -> Class Library project. It basically get Windows username and return it. Please note that, in order to get this compiled, you have to go into project settings and mark … Read more
This comes up repeatedly in SO questions, I’ll try to turn this into a (long) reference answer. 32-bit code is saddled with a long history of incompatible calling conventions. Choices on how to make a function call that made sense a long time ago but are mostly a giant pain in the rear end today. … Read more
I’ve found the simplest way to do this is to import the two methods with different names, and calling the right one. The DLL won’t be loaded until the call is made so it’s fine: [DllImport(“MyDll32.dll”, EntryPoint = “Func1”, CallingConvention = CallingConvention.Cdecl)] private static extern int Func1_32(int var1, int var2); [DllImport(“MyDll64.dll”, EntryPoint = “Func1”, CallingConvention … Read more
There is no way to directly use a C++ class in C# code. You can use PInvoke in an indirect fashion to access your type. The basic pattern is that for every member function in class Foo, create an associated non-member function which calls into the member function. class Foo { public: int Bar(); }; … Read more
The issue I filed on GH has been sitting there for quite some time. I believe that this behavior is simply a bug and no more time needs to be spent looking into it.
First, understand that the code is wrong (and always has been). The “pInvokeStackImbalance” is not an exception per se, but a managed debugging assistant. It was off by default in VS2008, but a lot of people did not turn it on, so it’s on by default in VS2010. The MDA does not run in Release … Read more
I’ve stolen some code I found on the MSDN forums and made an extension method on the Window class, like this: internal static class WindowExtensions { // from winuser.h private const int GWL_STYLE = -16, WS_MAXIMIZEBOX = 0x10000, WS_MINIMIZEBOX = 0x20000; [DllImport(“user32.dll”)] extern private static int GetWindowLong(IntPtr hwnd, int index); [DllImport(“user32.dll”)] extern private static int … Read more
Here is a solution. It uses p/invoke, but seems to work well, 32 or 64 cpu: /// <summary> /// A utility class to determine a process parent. /// </summary> [StructLayout(LayoutKind.Sequential)] public struct ParentProcessUtilities { // These members must match PROCESS_BASIC_INFORMATION internal IntPtr Reserved1; internal IntPtr PebBaseAddress; internal IntPtr Reserved2_0; internal IntPtr Reserved2_1; internal IntPtr UniqueProcessId; … Read more