Develop Reference

Passing C# 'string' in C++ dll as 'Char*'

Hi I have create c++ function as
void MyClass::GetPRM(BSTR BString)
{
//----
}
In C# the dll interface looks like:
GetPRM(char* BString)
My question is how can I pass string as char* from c# to c++ dll?
I have tried doing
void MyClass::GetPRM(std::string BString) but no luck.
Any Suggestions

You should be able to use
[DllImport("mycppdll", EntryPoint="MyClass_GetPRM")]
extern static void GetPRM([MarshalAs(UnmanagedType.BStr)] string BString)
However, that doesn't take into account C++ name-mangling, nor your C++ method's this pointer if that method is not declared static.
On the C side, you may need a wrapper function like this:
extern "C" __declspec(dllexport) void __stdcall
MyClass_GetPRM(BSTR BString)
{
MyClass::GetPRM(BString);
}
which would require adaptation of the C# declaration to match the exported name:
[DllImport("mycppdll", EntryPoint="MyClass_GetPRM")]
extern static void GetPRM([MarshalAs(UnmanagedType.BStr)] string BString)

Triggering event in C# from C++ DLL

I have an umanaged C++ DLL which is communicating with a Cisco Server (UCCX).
It sends and receives messages to and from this server via TCP/IP. Now there are some types of messages it receives which contains some parameters which it needs to send to a C# GUI which will display these parameters on screen.
Please tell me an efficient method to trigger an event in C# from this DLL.

http://blogs.msdn.com/b/davidnotario/archive/2006/01/13/512436.aspx seems to answer your question. You use a delegate on the C# side and a standard callback on the C++ side.
C++ side:
typedef void (__stdcall *PFN_MYCALLBACK)();
int __stdcall MyUnmanagedApi(PFN_ MYCALLBACK callback);
C# side
public delegate void MyCallback();
[DllImport("MYDLL.DLL")] public static extern void MyUnmanagedApi(MyCallback callback);
public static void Main()
{
MyUnmanagedApi(
delegate()
{
Console.WriteLine("Called back by unmanaged side");
}
);
}

Note the C++ side should be
typedef void (__stdcall *PFN_MYCALLBACK)();
extern "C" __declspec(dllexport) void __stdcall MyUnmanagedApi(PFN_ MYCALLBACK callback);
An alternate option is to drop the __stdcall on the C++ side
typedef void (*PFN_MYCALLBACK)();
extern "C" __declspec(dllexport) void MyUnmanagedApi(PFN_ MYCALLBACK callback);
And on the C# side:
public delegate void MyCallback();
[DllImport("MYDLL.DLL", CallingConvention = CallingConvention.Cdecl))]
public static extern void MyUnmanagedApi(MyCallback callback);
as above ...

p/invoke calling C dll from c#

this is my C code
extern "C"
{
__declspec(dllexport) void DisplayHelloFromDLL(string a)
{
printf ("%s\n",a)
}
}
this is my C# code
class HelloWorld
{
[DllImport("TestLib.dll")]
public static extern void DisplayHelloFromDLL(string a);
static void Main ()
{
string a = "Hello";
DisplayHelloFromDLL(a);
}
}
It built successfully but crash like this:
SO,how to use P/invoke to call my own C dll from C#?
Please help,thanx in advance.

First of all your code is C++ rather than C. Your function receives a parameter of type std::string and the use of std::string means that your code is actually C++.
Now this parameter type is the root of your problem. You cannot create a std::string in .net and instead will need to use a char* to pass the string data. The following code is what you need:
C++
__declspec(dllexport) void DisplayHelloFromDLL(char* a)
{
printf("%s\n", a);
}
C#
[DllImport("TestLib.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void DisplayHelloFromDLL(string a);
static void Main ()
{
string a = "Hello";
DisplayHelloFromDLL(a);
}
The default p/invoke marshalling for a .net string is to pass a char* as an [In] parameter. There is no need for the complexity of IntPtr, StringToHGlobalAnsi, FreeHGlobal as suggested by one of the other answers. If you can let the p/invoke marshaller do the work then it is preferable to do so.
Note that you also need to make sure that your calling conventions match. Under the assumption that you have not used any special compiler options when building your C++ code, that code will default to used cdecl calling convention. You can make that match with the CallingConvention parameter to the DllImport attribute.

Please take a look at marshalling string at MSDN
In a nut shell, a C# string doesn't get marshalled as std::string but a char* by default

For one thing the return type is not matching. In C it is void and in C# int.

Change your C++ param type to char* and update your C# code as following
class HelloWorld
{
[DllImport("TestLib.dll")]
public static extern void DisplayHelloFromDLL(IntPtr a);
static void Main ()
{
string a = "Hello";
var ptr = System.Runtime.Marshal.StringToHGlobalAnsi(a);
DisplayHelloFromDLL(ptr);
System.Runtime.Marshal.FreeHGlobal(ptr);
}
}

Calling C++ function using DllImport

This one is basic, how do I call the function SubscribeNewsFeed in the following from a C# DllImport?
class LogAppender : public L_Append
{
public:
LogAppender()
: outfile("TestLog.txt", std::ios::trunc | std::ios::out)
, feedSubscribed(false)
{
outfile.setf(0, std::ios::floatfield);
outfile.precision(4);
}
void SubscribeNewsFeed()
{
someOtherCalls();
}
};
I'm unable to figure out how to include the class name when using the DllImport in my C# program here:
class Program
{
[DllImport("LogAppender.dll")]
public static extern void SubscribeNewsFeed();
static void Main(string[] args)
{
SubscribeNewsFeed();
}
}

PInvoke cannot be used to call directly into a C++ function in this way. Instead you need to define an extern "C" function which calls the PInvoke function and PInvoke into that function. Additionally you cannot PInvoke into a class instance method.
C / C++ Code
extern "C" void SubscribeNewsFeedHelper() {
LogAppender appender;
appender.SubscribeNewsFeed();
}
C#
[DllImport("LogAppender.dll")]
public static extern void SubscribeNewsFeedHelper();

P/Invoke doesn't work that way. It only can import C functions. So there are different types of interop between the managed (C#) and native (C++) world. Interop via COM would be a solution - providing a C interface another.

calling a C++ function from C# and sending data back to the C#

I have a C# application that calls functions in a DLL written in C++. The calls work fine and the code is executed using this method in the C#:
[DllImport("myDLL.dll")]
public static extern void Function();
static void Main()
{
Function();
}
Now this works, I need the executing C++ code to send back the text to the C# where it can be displayed in a panel.
The text is "stage one..." executes code...then "stage two" etc, showing the processes running. Just basic stuff. I'm not sure how to approach this as I'm not a C++ guy. My main skills are .NET.
Cheers

Try using callbacks in C++ and sign them in C#
C++ part
typedef void (CALLBACK *pfNotifyMessage)(LPTSTR);
extern "C" AFX_API_EXPORT void SetNotifyMessage(pfNotifyMessageType pfNotify);
extern "C" AFX_API_EXPORT void Function();
In C++ Function call make call of pfNotifyMessage
C# part
public delegate void NotifyMessage(string message);
[DllImport("myDLL.dll")]
public static extern void SetNotifyMessage(NotifyMessage notify);
[DllImport("myDLL.dll")]
public static extern void Function();
in С# assign delegate with function