We Keep Coding

Passing String from C function to C#

I have the following test function set up in a C project:
__declspec(dllexport) int test(char *str, int strlen){
char* h = "Hello";
int length = 5;
for(int i = 0; i < length; i++){
str[0] = h[0];
}
return strlen;
}
And in my C# project I declare the method as follows:
[DllImport("solver.dll", CharSet = CharSet.Unicode ,CallingConvention = CallingConvention.Cdecl)]
public static extern int test(StringBuilder sol, int len);
And I try to use it in my project like so:
StringBuilder sol = new StringBuilder(15);
int t = test(sol, sol.Capacity);
string str = sol.ToString();
I'd like to pass "Hello" back to the C# code as a test, but when I run the code the StringBuilder stays empty, and even though 15 is passed to the C function as the length, when the C function returns the length it returns a 'random' large number like 125822695. What am I missing?

A number of problems:
You state CharSet.Unicode in the C#, but use ANSI in the unmanaged code.
You only write to the first character.
You ignore the value of strlen passed to the function.
You don't attempt to write a null-terminator.
As for the value returned from the function, that cannot be explained by the code that you present. There is something missing from your question that we need to see in order to explain that.
It is quite common when we see these questions, that the unmanaged code is clearly broken. It's hard enough to write correct p/invokes to correct unmanaged code. Trying to debug the p/invoke and the unmanaged code at the same time is so much harder. Test your unmanaged code in an unmanaged setting first. Only when you are confident it is correct should you move to write your p/invoke.

What is the correct syntax for calling this C function in C#? The function uses pointers and arrays

I'm trying to call a function from a DLL written in C. I need to call the function in C#, but I believe I'm running into issues with the syntax. I have a working example that uses the ctypes library in Python. Unfortunately the DLL requires a dongle to run, so right now I'm looking for help regarding any obvious discrepancies in the syntax between C, Python, and C#.
The C function has the format
int (int nID, int nOrientation, double *pMTFVector, int *pnVectorSize );
(I'm really unfamiliar with pointers and the PDF documentation has the asterisks surrounded by spaces so I'm not sure what the asterisk should be attached to)
The function of this code is to accept nID and nOrientation to specify features in an image, and then populate an array with values. The documentation describes the outputs below:
out; pMTFVector; array of MTF values, memory is allocated and handled by application, size is given by pnVectorSize
in,out; pnVectorSize maximum number of results allowed to store in pMTFVector, number of results found and stored in pMTFVector
The python code that actually works is:
lib=cdll.LoadLibrary("MTFCameraTester.dll")
lib.MTFCTGetMTF(c_uint(0), c_int(0), byref((c_double * 1024)()), byref(c_uint(1024)))
The code I've tried is:
[DllImport("MTFCameraTester.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
public extern static MTFCT_RETURN MTFCTGetMTF(UInt32 nID, int orientation, double[] theArray, IntPtr vectorSize);
double[] myArray = new double[1024];
IntPtr myPtr = Marshal.AllocHGlobal(1024);
returnEnum = MTFCTGetMTF(0, 0, myArray, myPtr);
When the code is run my returnEnum is -1, which is specified as an error in the documentation. This is the best result I've come across, as I've had many Stack Overflow errors when trying varying combinations of ref and out

You are nearly there. The final argument is the problem I think. Try like this:
[DllImport("MTFCameraTester.dll", CallingConvention = CallingConvention.Cdecl)]
public extern static MTFCT_RETURN MTFCTGetMTF(
uint nID,
int orientation,
[Out] double[] theArray,
ref int vectorSize
);
....
double[] myArray = new double[1024];
int vectorSize = myArray.Length;
MTFCT_RETURN returnEnum = MTFCTGetMTF(0, 0, myArray, ref vectorSize);

The VB.NET solution that worked was:
<DllImport("MTFCameraTester.dll", CallingConvention:=CallingConvention.Cdecl)> _
Function MTFCTGetMTF(ByVal id As UInt32, ByVal orientation As UInt32, ByRef data As Double, ByRef len As UInt32) As Integer
End Function
Dim ret As Integer
Dim dat(1023) As Double
Dim len As UInt32 = 1024
ret = MTFCTGetMTF(0, 0, dat(0), len)
It seems like I had to pass the first element of the array to the C function, and then it took care of the rest.

C# marshalling char* to StringBuilder get always empty string

I am developing a C++ library and a C# application that should consume it.
The library takes two numeric input arguments and one string output parameter.
My problem is that in the C# application i get always an empty string for this parameter. Here is my code.
C++ side:
typedef struct sharedItem{
unsigned int tagId;
unsigned char tagValue[256];
}sharedItem;
extern "C" {
int getSharedMemoryVariable(char* value, unsigned int variableTagId, int foundVariables)
{
sharedItem *item;
set item properly...
strcpy(value, (char *)item->tagValue);
check result and return properly...
}
}
C# side
[DllImport("C:\\SharedMemory.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)]
public static extern int getSharedMemoryVariable(StringBuilder variableValue, UInt16 variableTagId, Int16 foundVariables);
StringBuilder value = new StringBuilder(256);
res = SharedMemory.getSharedMemoryVariable(value, 45, 14730);
My problem is that variable value is always an empty string. Please note that, in C++ side, if I replace
strcpy(value, (char *)item->tagValue);
with
strcpy(value, "test");
the application works fine.
I hope somebody can help me.
Thank you

EDIT:
[DllImport] already pins parameters; and there's no need for unsafe code
Thanks #dan
Anyway that can be fixed by doing a memset(item->tagValue, '\0', 256*sizeof(char));

Passing string from c++ to c#

I'm trying to pass string from c++ to c#.
C++:
extern "C" __declspec(dllexport) void GetSurfaceName(wchar_t* o_name);
void GetSurfaceName(wchar_t* o_name)
{
swprintf(o_name, 20, L"Surface name");
}
C#:
[DllImport("SurfaceReader.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern void GetSurfaceName(StringBuilder o_name);
StringBuilder name = new StringBuilder(20);
GetSurfaceName(name);
But only first symbol is passed: name[0] == 'S'. Other symbols are nulls. Could you tell me what is wrong here?
Thanks,
Zhenya

You forgot to tell the pinvoke marshaller that the function is using a Unicode string. The default is CharSet.Ansi, you'll need to use CharSet.Unicode explicitly. Fix:
[DllImport("SurfaceReader.dll",
CallingConvention = CallingConvention.Cdecl,
CharSet = CharSet.Unicode)]
private static extern void GetSurfaceName(StringBuilder o_name);
You'll get a single "S" now because the utf-16 encoded value for "S" looks like a C string with one character.
Do in general avoid magic numbers like "20". Just add an argument that say how long the string buffer is. That way you'll never corrupt the GC heap by accident. Pass the StringBuilder.Capacity. And give the function a return value that can indicate success so you also won't ignore a buffer that's too small.

I am not sure, but instead of using StringBuilder, I would pass from C# char (wchar) array to C++, fill it and then operate with this array in C#.

Native C-DLL in C# AccessViolation/Marshalling

I have a problem with calling a C DLL fom C#
The C function is (I don't have a c header or a good spec for this :( )
int knr12_read ( char *kn12, char *ik9, char *wok, char *wlc,
char *plz, char *ort, char *woz );
kn12 is a ref parameter
This is what I've tried in C#
[return: MarshalAs(UnmanagedType.U4)]
[DllImport("Knr12.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "knr12_read", CharSet = CharSet.Ansi)]
unsafe public static extern int knr12_read(out IntPtr buffer, string ik9, string wok, string wlc, string plz, string ort, string woz);
int knr = knr12_read(out pBuffer, knrTemp, "11111", "", "98529", "Suhl", "1");
string data = Marshal.PtrToStringAnsi(pBuffer);
The returning int is always right, how it should be, but I have problems with the ref parameter pBuffer...
Also the sting type for the other variables is working...
When I use a ref,I always get an AccessViolation error knr12_read().In case I use out I get a pointer,but the String is always empty which can't be.I even tried out String as ref for char* but I get an AccessViolation error on knr12_read().
Please guide.

StringBuilder is often a good type to use when P/Invoking to functions with string returning parameters:
static extern int knr12_read(StringBuilder kn12, ...)
You'll need to initialise the string builder before you call the function, something like:
StringBuilder outString = new StringBuilder(100);
You shouldn't need the 'unsafe', and unless the 'C' code holds onto the pointers for longer than the duration of the call, you shouldn't need to worry about pinning - the framework is doing that for you.
Here's a SO question which should help: Marshal "char *" in C#

Probably you have not pinned the buffer. here is the example of how to pin the buffer data.
GCHandle pinnedRawData = GCHandle.Alloc(rawData,
GCHandleType.Pinned);
Pinning the object makes sure that the pointer is valid cause .Net runtime can always reallocate the memory as and when it thinks fit.
Try it out and let me know if it helps you.