pinvokestackimbalance -- how can I fix this or turn it off?

I just switched to vs2010 from vs2008. Exact same solution, except now every single call to a C++ dll yields a 'pinvokestackimbalance' exception.

This exception does not get fired in 2008. I have complete access to the C++ dll and to the calling application. There does not appear to be any problem with the pinvoke, but this problem is making debugging other problems impossible; the IDE is stopping constantly to tell me about these things.

For instance, here's the C# signature:

    [DllImport("ImageOperations.dll")]
    static extern void FasterFunction(
        [MarshalAs(UnmanagedType.LPArray)]ushort[] inImage, //IntPtr inImage, 
        [MarshalAs(UnmanagedType.LPArray)]byte[] outImage, //IntPtr outImage, 
        int inTotalSize, int inWindow, int inLevel);

Here's what it looks like on the C++ side:

#ifdef OPERATIONS_EXPORTS
#define OPERATIONS_API __declspec(dllexport)
#else
#define OPERATIONS_API __declspec(dllimport)
#endif
extern "C" {


OPERATIONS_API void __cdecl FasterFunction(unsigned short* inArray, 
									   unsigned char* outRemappedImage,
									   int inTotalSize, 
									   int inWindow, int inLevel);

}

What's different between vs2010 and vs2008 that would cause these exceptions to get thrown? Should I be adding a different set of parameters to the DllImport directive?

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 mode, so it won't trigger if you build for release.

In your case, the calling convention is incorrect. DllImport defaults to CallingConvention.WinApi, which is identical to CallingConvention.StdCall for x86 desktop code. It should be CallingConvention.Cdecl.

This can be done by editing the line [DllImport("ImageOperations.dll")] to be:

[DllImport("ImageOperations.dll", CallingConvention = CallingConvention.Cdecl)]

For more information, see this MSDN reference

To turn it off:

> 1. CTRL + ALT + E > 2. Under "Managed Debugging Assistants" uncheck PInvokeStackImbalance.

Better to solve this issue its not much difficult here I am mentioning some of the methods, it may same as some of my friends mentioned above. I am working with PCSC a Smartcard application I spend around one week, get pissed off did lot of changes finally got the solutions.

For me its work with PInvoke Extension which I installed for VS2010 you can download it here http://www.red-gate.com/products/dotnet-development/pinvoke/

Download it and install it, Close visual studio and open again you can find extension at Menu Bar.

If the error is because of signature not matching you just click on PInvoke.net> Insert PInvoke Signatures

The new window will appear like below

Enter the name of the dll and click on search you can see the all the functions of that dll in search result window, Click on the function you will get a signature for that particular Function.

Use that signature and you need to modify your programs according to that Signature, Mostly the data Type.

This solve my problem you might have different problem like callingConvention or additional attributes need to specify while importing dll.

Happy Coding Be well!

I got this problem also when using VS2010. What it is: Visual Studio defaults to 64 bit code for 'any CPU'. The pointers to variables (eg. strings) now become 64 bit when calling your external Dlls, where as all your reliable and trusted Dlls use 32 bit pointers.

Don't assume there is anything wrong with your Dlls, there isn't.

Change your VS settings to generate X86 code like this (Express versions of C#)

> 1. go to Tools -> Options. > 2. In the bottom-left corner of the Options dialog, check the box that says, "Show all settings". > 3. In the tree-view on the left hand side, select "Projects and Solutions". > 4. In the options on the right, check the box that says, "Show advanced build configuraions." > 5. Click OK. > 6. Go to Build -> Configuration Manager... > 7. In the Platform column next to your project, click the combobox and select "". > 8. In the "New platform" setting, choose "x86". > 9. Click OK. > 10. Click Close.

I notice also, that even though computers have doubled in power every 12 months, my current computer with 1gig of RAM, seems no faster than my first 486 with 4 Meg. Don't worry about using 64 bit code, it's not going to be faster or better because it is built on a huge cumbersome object-orientated tower of bloat.

I tried to call dll with the CallingConvention is ThisCall and it worked for me. Here is my code working with BLOB MS Sql Server.

[DllImport("sqlncli11.dll", SetLastError = true, CharSet = CharSet.Unicode, CallingConvention = CallingConvention.ThisCall)]
            private static extern SafeFileHandle OpenSqlFilestream(
                        string FilestreamPath,
                        UInt32 DesiredAccess,
                        UInt32 OpenOptions,
                        byte[] FilestreamTransactionContext,
                        UInt32 FilestreamTransactionContextLength,
                        Int64 AllocationSize);

More at: https://msdn.microsoft.com/en-us/library/system.runtime.interopservices.callingconvention(v=vs.110).aspx