Re: communication between C# dll and C++ dll ???

<njoycoding@gmail.com> ha scritto nel messaggio
news:00b9e7ea-db4f-41bf-98ae-ea0d142a5099@v26g2000prm.googlegroups.com...


Suppose that you have a C# class that has a read-write 'Text' property
which is a String (C# .NET String).
This class is called 'CSharpClass' and is in the namespace TestCSharpLib1.

* CSharpClass:
- properties:
   + Text (String) (read/write)
- methods:
   + SayHello

You can use the new marshal library in VS2008 to help you marshal strings
between C++ and C#.

Suppose you have an MFC application (.exe) and you want to marshal the
string from C++ (CStringW / const wchar_t *) to C#, and back.

First you must enable CLR support in the MFC .exe.
You can do that selecting the properties menu of your MFC project (right
click on project item in Solution Explorer, and select 'Properties' in the
popup menu).

Then select 'Configuration Properties'.
Then, in the item 'Common Language Runtime support: ', select the value:

'Common Language Runtime support (/clr)'

Then you should include the following lines after the normal #include's
lines in the .cpp source file where you are going to call the C# class.
The purpose of these lines is to use the marshal library of VS2008:

<code>
// Use the marshal library in VS2008
#include <msclr/marshal.h>
using namespace msclr::interop;
</code>

At this point, you can use the marshal_as<> template.

I posted a sample code from a project of mine, that does both directions
marshaling: C++ -> C# and back C# --> C++.
The code is commented, so you can read the comments for each step:

<code>

//
// TEST of string marshaling between C# and C++
//
void CMfcCallsCSharpDlg::OnBnClickedBtnCallCs()
{
   // Create an instance of the C# class
   // on the managed heap (using gcnew)
   TestCSharpLib1::CSharpClass ^ csharpClass = gcnew
TestCSharpLib1::CSharpClass();

   // Read user's text from edit control
   CStringW strText;
   m_txtInput.GetWindowText( strText );

   // Prepare marshal context for marshaling string between C# and C++
   marshal_context ^ marshalCtx = gcnew marshal_context();

   //
   // Marshal string from C++ (CStringW - const wchar_t *)
   // to C# (System::String ^)
   //
   System::String ^ s = marshalCtx->marshal_as< System::String ^ >(
static_cast< PCWSTR >( strText ) );

   // Set string property into C# object
   csharpClass->Text = s;

   // Invoke test method of C# object
   csharpClass->SayHello();

   //
   // Inverse marshaling, from C# to C++
   //

   // Convert from C# string back to C++ string
   CStringW strFromCS;
   strFromCS = marshalCtx->marshal_as< PCWSTR >( csharpClass->Text );

   // Show the string from C#
   CStringW strMsg = L"String from C# : ";
   strMsg += strFromCS;
   AfxMessageBox( strMsg );

   // Cleanup marshal context
   delete marshalCtx;
}

</code>

Another option to communicate between C# and C++ is to use COM, but I do
prefer the C++/CLI extensions of VS2008 - I think that it is simpler.

However, if your C++ MFC project is built using Visual C++ 6, you must use
COM, because there is no C++/CLI extension in Visual C++ 6.
(C++/CLI extensions are one of the top reasons to move to VS2008, IMHO.)

HTH,
Giovanni