(cont'd) Callback interface to communicate from native C++ -> CLi\C++Options

[DaTurk]

Sorry, some how I clicked post before I finished.

Hi,

I'm writing an application that has a native c++ layer, and a CLi/C++
layer above it. Above the CLi layer will be C# but that's not
relavent to this post. My question has to do with communicating
between the native layer to the CLi layer. Typically how I do this
is
this ...
**CLi/C++ Layer**

*************** ***************
--MTest.h

namespace Test
{
private delegate void TestDelegate(In t32);

public ref class Test
{
private:
GCHandle testHandle_;
TestDelegate^ testDelegate_;

UnmanagedTest* uTest_;

void init();
void registerNativeC allback();

void TestCallback(In t32);
public:
Test();
}
}

*************** ***************

--MTest.cpp

#include "Test.h"

using namespace Test;

Test::Test()
{
init();
registerNativeC allback();
}

void Test::init()
{
uTest_ = new UnmanagedTest() ;

testDelegate_ = gcnew TestDelegate( this, &Test::TestCall back );
testHandle_ = GCHandle::Alloc ( testDelegate_, GCHandle::Norma l );
}

void Test::registerN ativeCallback()
{
IntPtr ip =
Marshall::GetFu nctionPointerFo rDelegate( testDelegate_ );
uTest_->RegisterCallba ck( static_cast< void(__stdcall *)(int)

>( ip.ToPointer() ) );

}

void Test::TestCallb ack(Int32 pointlessParam)
{
}

*************** ***************

The unmanged class UnmanagedTest is just a native class that has a
function pointer variable that is set by the call to RegisterCallbac k.

My question is this, I need to do the exact same thing that I'm doing
here, but with an interface.

Is this possible? And if it is, can you please either show me how or
point me in the right direction?

Thank you in advance,

Matthew

[Giovanni Dicanio]

"DaTurk" <mm******@hotma il.comha scritto nel messaggio
news:9a******** *************** ***********@8g2 000hse.googlegr oups.com...

**CLi/C++ Layer**

public ref class Test
{
private:
[...]
UnmanagedTest* uTest_;
[...]
*************** ***************

--MTest.cpp
[...]
void Test::init()
{
uTest_ = new UnmanagedTest() ;
[...]
The unmanged class UnmanagedTest is just a native class

I think that you should use the IDispose pattern for that class.
In fact, you create an instance of the *unmanaged* class UnmanagedTest() -
using C++ 'new' - but this instance must be freed properly (else you can
have leaks).

My question is this, I need to do the exact same thing that I'm doing
here, but with an interface.

Sorry, but I don't understand this part...

What should be defined as an interface?
What should this interface seem like? What should be the purpose of this
interface?

Thanks,
Giovanni