> If I see it correctly, you're passing a managed method as an unmanaged
> pointer. That's not going to work. You have to write a global unmanaged
> function (in MC++ or C++/CLI) that calls back to the managed code, and
> pass this intermediate function to the unmanaged API. There's no way you
> can pass a managed callback to an unmanaged library without this
> intermediate layer.

> Also, you can't pass a managed void* to the unmanaged part either, at
> least not without pinning it.

> Tom

> //////////////////////////////////////////////////////////////////
> // For MC++:
> #include "stdafx.h"
> #include <vcclr.h>

> #using <mscorlib.dll>

> using namespace System;

> typedef void (*Callback)(void* param);

> void Process(Callback callback, void* param)
> {
>    if(callback) callback(param);
> }

> __gc class C
> {
> public:
>    void ProcessMe();
>    void OnProcess() // the callback implementation
>    {
>       Console::WriteLine(S"OnProcess");
>    }
> };

> class Bridge
> {
> public:
>    Bridge(C* in) : c(in) { }
>    static void ForwardOnProcess(void* param)
>    { static_cast<Bridge*>(param)->c->OnProcess(); }
> private:
>    gcroot<C*> c;
> };

> void C::ProcessMe()
> {
>    Bridge b(this);
>    ::Process(&Bridge::ForwardOnProcess, &b);
> }

> int _tmain()
> {
>    C* c = new C;
>    c->ProcessMe();
>    return 0;
> }

> //////////////////////////////////////////////////////////////////
> // For C++/CLI:
> #include "stdafx.h"
> #include <vcclr.h>

> using namespace System;

> typedef void (*Callback)(void* param);

> void Process(Callback callback, void* param)
> {
>    if(callback) callback(param);
> }

> ref class C
> {
> public:
>    void ProcessMe();
>    void OnProcess() // the callback implementation
>    {
>       Console::WriteLine(L"OnProcess");
>    }
> };

> class Bridge
> {
> public:
>    Bridge(C^ in) : c(in) { }
>    static void ForwardOnProcess(void* param)
>    { static_cast<Bridge*>(param)->c->OnProcess(); }
> private:
>    gcroot<C^> c;
> };

> void C::ProcessMe()
> {
>    Bridge b(this);
>    ::Process(&Bridge::ForwardOnProcess, &b);
> }

> int main(array<System::String^>^ args)
> {
>    C^ c = gcnew C;
>    c->ProcessMe();
>    return 0;
> }

> Tom

> Good idea, thanks Willy.

>>  // private inner non GC class used as thunk to callback into managed
>> code
>>     __nogc class _C

> VC++ 2005 doesn't allow me to define an unmanaged class in a managed one:

> ref class Managed
> {
> private:
>    class Unmanaged
>    {
>    };
> };

> error C2814: 'Managed::Unmanaged' : a native type cannot be nested within
> a managed type 'Managed'
> Tom

> "Tamas Demjen" <tdem...@yahoo.com> wrote in message
> news:eT2tRhsvFHA.916@TK2MSFTNGP10.phx.gbl...
>> Willy Denoyette [MVP] wrote:
>>> IMO it's more flexible when using (typesafe) delegates...

>> Good idea, thanks Willy.

>>>  // private inner non GC class used as thunk to callback into managed
>>> code
>>>     __nogc class _C

>> VC++ 2005 doesn't allow me to define an unmanaged class in a managed one:

>> ref class Managed
>> {
>> private:
>>    class Unmanaged
>>    {
>>    };
>> };

>> error C2814: 'Managed::Unmanaged' : a native type cannot be nested within
>> a managed type 'Managed'
>> Tom

> Tom,

> I know, and it's unfortunate C++/CLI does not support nested native types
> (or mixed types), so you'll have to use the same "hack" as you did to make
> it work but now using delegates. I guess there might be a cleaner way to
> achieve the same.

> #pragma unmanaged
> class Unmanaged
> {
>   public:
>   void Process(void (__stdcall *ptr) (void*, int), void* param)
>   {
>   int i = 10;
>   if(ptr != 0)
>      ptr( param, i);
>   }
> };

> // managed code from here
> #pragma managed

> public ref class C
> {
>   public:
>  delegate void CbckProc(int);

>  //Managed static callback
>  static void OnProcess(int v)
>   {
>   System::Console::WriteLine("Test {0}", v);
>   }
>    // Managed member callback
>   void OnProcess2(int v)
>   {
>   System::Console::WriteLine("Test2 {0}", v);
>   }

>  void ProcessMe();
>  CbckProc^ m_cbProc;
> };

> class Thunk
> {
> //     private:
>  public:
>  Thunk(C^ in):m_pClass(in){}
>  static void __stdcall CallbackProc(void* param, int v)
>  {
> // here is the "ugly" cast back again
>  static_cast<Thunk*>(param)->m_pClass->m_cbProc->Invoke(v);
>  }
>  gcroot<C^> m_pClass;
> };

> void C::ProcessMe()
>  {
>  Thunk b(this);
>  m_cbProc = gcnew CbckProc(&C::OnProcess);
>  Unmanaged* n = new Unmanaged();
>  n->Process(Thunk::CallbackProc, &b);
>  m_cbProc = gcnew CbckProc(this, &C::OnProcess2);
>  n->Process(Thunk::CallbackProc, &b);
>  }

> int main()
> {
>   C c;
>   c.ProcessMe();
> }