CODEWITHSUNDEEP
c#c++winapipinvoke
losingsleeep
losingsleeep

Reputation: 1879

Win32 api call via C# fails!

I have a C++ function exported as api like this:

#define WIN322_API __declspec(dllexport)
WIN322_API char* Test(LPSTR str);
WIN322_API char* Test(LPSTR str)
{
 return "hello";
}

the function is exported as API correctly by the .DEF file, cause i can see it in Dependency Walker tool. Now i have a C# tester program:

[DllImport("c:\\win322.dll")]

public static extern string Test([MarshalAs(UnmanagedType.LPStr)] String str);

private void Form1_Load(object sender, EventArgs e)
        {
string _str = "0221";
Test(_str); // runtime error here!

}

on calling the Test() method i get the error:

"A call to PInvoke function 'MyClient!MyClient.Form1::Test' has unbalanced the stack. This is likely because the managed PInvoke signature does not match the unmanaged target signature. Check that the calling convention and parameters of the PInvoke signature match the target unmanaged signature."

i tried many other data types and marshalings, but got nothing! plz help me!

Upvotes: 3

Views: 1313

Answers (6)

Daniel Rose
Daniel Rose

Reputation: 17648

Make sure that you have the correct calling convention. Your DLL may use Cdecl, while C# defaults to StdCall. It's better to always explicitly define the calling convention.

Especially when using Windows functions which exist in an ANSI and wide char version (those with an A or W prefix), explicitly specify the CharSet so the correct version is used.

When the function returns a value, explictly marshal the return value. Otherwise, the compiler chooses a default, which may be wrong. I suspect this is (also) the problem here.

So change to this, for example:

[DllImport("c:\\win322.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.LPStr)]
public static extern string Test([MarshalAs(UnmanagedType.LPStr)] String str);

Upvotes: 1

Hans Passant
Hans Passant

Reputation: 942197

It is caused by a mismatch on the calling convention, the default for [DllImport] is Stdcall but the C compiler's default is Cdecl. Use the CallingConvention property in the declaration.

That's not the only problem though, this code will crash on Vista and Win7. Returning a string from a C function is quite troublesome, there's a memory management problem. It isn't clear who is responsible for freeing the string buffer. You are returning a literal now but that's going to stop being useful pretty soon. Next stop is using malloc() for the return string with the intent for the caller to call free(). That's not going to work, the pinvoke marshaller cannot call it since it doesn't know what heap the C code is using.

It will call Marshal.FreeCoTaskMem(). That's wrong, the string wasn't allocated by CoTaskMemAlloc(). That goes unnoticed on XP and earlier, other than the very hard to diagnose memory leak this causes. And goes kaboom on Vista and Win7, they have a much more stricter memory manager.

You need to rewrite the C function like this:

extern "C" __declspec(dllexport) 
void __stdcall Test(const char* input, char* output, int outLen);

Now the caller supplies the buffer, through the output argument, there's no longer a guess who owns the memory. You use StringBuilder in the C# declaration.

[DllImport("foo.dll")]
private static extern void Test(string input, StringBuilder output, int outLen);
...
    var sb = new StringBuilder(666);
    test("bar", sb, sb.Capacity);
    string result = sb.ToString();

Be careful to use the outLen argument in your C code so that you can be sure not to overflow the buffer. That corrupts the garbage collected heap, crashing the app with a Fatal Execution Engine Error.

Upvotes: 5

atzz
atzz

Reputation: 18010

Change your macro definition to

#define WIN322_API __declspec(dllexport) __stdcall

As an alternative, use CallingConvention.Cdecl when importing.

Read, for example, here for more info on calling conventions.

Upvotes: 2

bunn_online
bunn_online

Reputation: 752

Pass a StringBuilder from .Net as a parameter rather than returning a string (in this case it will be like an out parameter)

Upvotes: 0

Sarwar Erfan
Sarwar Erfan

Reputation: 18058

Use Unmanagedtype.LPTStr for the input. Notice the additional T

[MarshalAs(UnmanagedType.LPStr)] String str  // your current code
[MarshalAs(UnmanagedType.LPTStr)] String str // try this code

Upvotes: 0

fejesjoco
fejesjoco

Reputation: 11903

Try returning LPSTR, not char*. You might also need to specify stdcall calling convention, which is default in .NET, but I'm not sure about your unmanaged project.

Upvotes: 0

Related Questions