using c++ to call a managed C# DLL, that uses a c++ class.

// this is the class i want to pass.
class CCPlus
{
public:
	CCPlus();
	~CCPlus();
	void WriteToLog(char* toWrite);
	void setNumber(int num);
	void printNumber();
	int  getNumber();
	void setInternalString(char* str);
	void printInternalString();


private:
	int m_Number;
	CSTRHolder* m_holder;
};

//and the STRHolder:
class CSTRHolder
{
public:
	CSTRHolder(void);
	~CSTRHolder(void);
	void setString(char* str);
	char* getCopyOfString();
private:
	char* m_str;
};

void main()
{
  CCPlus* p = new CCPlus();
  p->setNumber(10);

  // now I want to call a C# dll, and pass the "p" pointer.
  // something like:
  int result =  MyManagedClass::DoOperation(&p);
  // where MyManagedClass is below:
}

namespace ManagedDotnet
{
    public class MyManagedClass
    {
        public static int DoOperation(CCPlusWrapper p)
        {
             Console.Writeline(p.getNumber());
             p.setInternalString("Hello");
             p.printInternalString();
             return 0;
        }
    }
}

// MyBridge.h

#pragma once

using namespace System;


class CCPlus;

public ref class Bridger
{
public:
	Bridger(CCPlus* myUnmanaged);
	~Bridger();
	void WriteToLog(String^ toWrite);
	void setNumber(int num);
	void printNumber();
	int  getNumber();
	void setInternalString(String^ str);
	void printInternalString();
private:
	CCPlus* m_pUnmanaged;

};

// This is the main DLL file.

#include "stdafx.h"
#include "MyBridge.h"
#include <stdio.h>
#include "CPlus.h"
#include <vcclr.h>
#include <iostream>

using namespace std;
using namespace System;
Bridger::Bridger(CCPlus* myUnmanaged)
:m_pUnmanaged(NULL)
{	
	this->m_pUnmanaged = myUnmanaged;	
}
Bridger::~Bridger()
{

}
void Bridger::WriteToLog(String^ toWrite)
{	
   // Pin so GC won't move the managed string around
   pin_ptr<const wchar_t> ptr = PtrToStringChars(toWrite);
   m_pUnmanaged->WriteToLog((char*)static_cast<const wchar_t*>( ptr ));   
}
void Bridger::setNumber(int num)
{
	m_pUnmanaged->setNumber(num);
}
void Bridger::printNumber()
{	
	m_pUnmanaged->printNumber();
}
int  Bridger::getNumber()
{
	return m_pUnmanaged->getNumber();
}
void Bridger::setInternalString(String^ str)
{
   pin_ptr<const wchar_t> ptr = PtrToStringChars(str);
   m_pUnmanaged->setInternalString((char*)static_cast<const wchar_t*>( ptr ));   
}
void Bridger::printInternalString()
{
	m_pUnmanaged->printInternalString();
}