Passing none static member function as callback parameter to manag

[Haxan]

Hi,

I have my main application class(unmanaged ) that has a none static member
function that I need to pass as a delegate to managed C# method.

In one of the methods of this class(unmamange d), I am calling a managed C#
method(I use gcnew to instantiate the managed class). One of the parameters
of this C# method is a delegate. I need to pass the none static member
function as a delegate(functi on pointer) as a parameter in the managed C#
function call.

e.g.

//Managed C#
namespace MySpace
{
public delegate int MyDelegate();

MyDelegate rDelegate;

public class Managed
{
void ManagedFunction (MyDelegate del)
{
//do stuff
}

}
}
//Unmanaged C++ written in VC++ 6.0

//.h
class Unmanaged
{
public:
Unmanaged();
~Unmanaged();

void UnmanagedFunc1( );
void UnmanagedFunc2( );

}

*.cpp
using namespace MySpace;

void Unmanaged::Unma nagedFunc1()
{
MySpace::Manage d ^man = gcnew MySpace::Manage d;

//I need to pass UnmanagedFunc2( ) here as a delegate/callback as a
//parameter to ManagedFunction .
man->ManagedFunctio n(??)

}

void Unmanaged::Unma nagedFunc2()
{

}

Will appreciate all the help I can get on this.

Also what if I need to pass a string also as a parameter to
ManagedFunction (). In unmanaged it is a char* or a CString. How can I do the
conversion to pass it to managed.

Thanks for the help.

[Haxan]

Hi Tamas,

Sorry for the confusion. Actually the code was originally written in VC++6
and it has been ported to .Net 2005 and compiled as C++/CLI and it is talking
to a managed C# application(dll ). I dont think you need to have an
intermediate dll in such a case. All I want to do is pass a function
pointer/delegate with a CString/char * parameter to managed C# function(one
of the parameters of the C# function is a delegate).

Im able to pass the delegate to managed C# function but cant pass the
CString/char * parameter(which is a parameter of this delegate).

Will appreciate your help.
THanks

"Tamas Demjen" wrote:

Haxan wrote:

Actually the unmanaged class is part of an old dll that was written using
VC++ 6.0. Since we later on started using managed code, the changes have to
be part of the dll.

You have to write a mixed-mode DLL, a translation layer between the C#
and the VC6 code. That mixed-mode DLL has to export native functions
that your VC6 code can call. In turn, it will internally set up the
managed event forwarder and calls the managed library function. This
intermediate DLL is necessary, because I don't think you can compile
C++/CLI code from VC6.

Tom

[Tamas Demjen]

Haxan wrote:

Im able to pass the delegate to managed C# function but cant pass the
CString/char * parameter(which is a parameter of this delegate).

OK, I modified my original example to pass a String instead of an int.
It also includes the String^ to const char* conversion. I don't see it
happening without an intermediate forwarder, which I called Thunk. It
can go to the C++/CLI DLL. In your case ManagedSender is written in C#,
but it shouldn't make any difference. The point is that ManagedSender
doesn't know anything about the receiver, it has no idea that it's
handled by an unmanaged class.

This is the best I can do to help you. I can't suggest anything that
automatically marshals the string without the intermediate Thunk object.
There may be something available that I'm not aware of.

Tom

#include "stdafx.h"
#include <vcclr.h>
#include <iostream>

using namespace System;

////////////////////////////////////////////
// C# DLL

#pragma managed

public delegate void ManagedEvent(St ring^ arg);

public ref class ManagedSender
// event sender
{
public:
event ManagedEvent^ SomeEvent;
void FireEvent()
{
SomeEvent("Hell o");
}
};

////////////////////////////////////////////
// Mixed native C++ / C++/CLI DLL

#pragma unmanaged

class UnmanagedReceiv er
{
public:
void HandleEvent(con st char* arg)
{
std::cout << arg << "\n";
}
};

#pragma managed

struct StringConvAnsi
{
char *szAnsi;
StringConvAnsi( String^ s)
: szAnsi(static_c ast<char*>(
Runtime::Intero pServices::Mars hal::StringToHG lobalAnsi(s).
ToPointer()))
{
}
~StringConvAnsi ()
{
Runtime::Intero pServices::Mars hal::FreeHGloba l(IntPtr(szAnsi ));
}
char* c_str() const
{
return szAnsi;
}

};

ref class Thunk
// event forwarder
{
public:
Thunk(Unmanaged Receiver* A_ptr) : ptr(A_ptr) { }
void CallbackForward er(String^ arg)
{
ptr->HandleEvent(St ringConvAnsi(ar g).c_str());
}
private:
UnmanagedReceiv er* ptr;
};

////////////////////////////////////////////
// Test application to set up the chain of calls

#pragma managed

int main(array<Stri ng ^^args)
{
UnmanagedReceiv er receiver;
ManagedSender^ sender = gcnew ManagedSender;
Thunk^ thunk = gcnew Thunk(&receiver );
sender->SomeEvent += gcnew ManagedEvent(th unk,
&Thunk::Callbac kForwarder);
sender->FireEvent();
return 0;
}

[Haxan]

Thanks Tom,

That was really helpful. Appreciate that.

"Tamas Demjen" wrote:

Haxan wrote:

Im able to pass the delegate to managed C# function but cant pass the
CString/char * parameter(which is a parameter of this delegate).

OK, I modified my original example to pass a String instead of an int.
It also includes the String^ to const char* conversion. I don't see it
happening without an intermediate forwarder, which I called Thunk. It
can go to the C++/CLI DLL. In your case ManagedSender is written in C#,
but it shouldn't make any difference. The point is that ManagedSender
doesn't know anything about the receiver, it has no idea that it's
handled by an unmanaged class.

This is the best I can do to help you. I can't suggest anything that
automatically marshals the string without the intermediate Thunk object.
There may be something available that I'm not aware of.

Tom

#include "stdafx.h"
#include <vcclr.h>
#include <iostream>

using namespace System;

////////////////////////////////////////////
// C# DLL

#pragma managed

public delegate void ManagedEvent(St ring^ arg);

public ref class ManagedSender
// event sender
{
public:
event ManagedEvent^ SomeEvent;
void FireEvent()
{
SomeEvent("Hell o");
}
};

////////////////////////////////////////////
// Mixed native C++ / C++/CLI DLL

#pragma unmanaged

class UnmanagedReceiv er
{
public:
void HandleEvent(con st char* arg)
{
std::cout << arg << "\n";
}
};

#pragma managed

struct StringConvAnsi
{
char *szAnsi;
StringConvAnsi( String^ s)
: szAnsi(static_c ast<char*>(
Runtime::Intero pServices::Mars hal::StringToHG lobalAnsi(s).
ToPointer()))
{
}
~StringConvAnsi ()
{
Runtime::Intero pServices::Mars hal::FreeHGloba l(IntPtr(szAnsi ));
}
char* c_str() const
{
return szAnsi;
}

};

ref class Thunk
// event forwarder
{
public:
Thunk(Unmanaged Receiver* A_ptr) : ptr(A_ptr) { }
void CallbackForward er(String^ arg)
{
ptr->HandleEvent(St ringConvAnsi(ar g).c_str());
}
private:
UnmanagedReceiv er* ptr;
};

////////////////////////////////////////////
// Test application to set up the chain of calls

#pragma managed

int main(array<Stri ng ^^args)
{
UnmanagedReceiv er receiver;
ManagedSender^ sender = gcnew ManagedSender;
Thunk^ thunk = gcnew Thunk(&receiver );
sender->SomeEvent += gcnew ManagedEvent(th unk,
&Thunk::Callbac kForwarder);
sender->FireEvent();
return 0;
}