Управляемый С++ для создания моста между С# и С++

Ответ 1

Пока я избил меня, чтобы написать пример, я отправлю его так или иначе на всякий случай...

Процесс написания обертки для доступа к вашей собственной библиотеке аналогичен процессу доступа к одной из стандартных библиотек .Net.

Пример кода класса С# в проекте CsharpProject:

using System;

namespace CsharpProject {
    public class CsharpClass {
        public string Name { get; set; }
        public int Value { get; set; }

        public string GetDisplayString() {
            return string.Format("{0}: {1}", this.Name, this.Value);
        }
    }
}

Вы создадите управляемый проект библиотеки классов С++ (например, CsharpWrapper) и добавьте ваш проект С# в качестве ссылки на него. Чтобы использовать тот же заголовочный файл для внутреннего использования и в проекте ссылок, вам нужен способ использования правильного declspec. Это можно сделать, указав в этом случае директиву препроцессора (CSHARPWRAPPER_EXPORTS) и используя #ifdef, чтобы установить макрос экспорта в свой C/С++-интерфейс в файле заголовка. Неуправляемый файл заголовка интерфейса должен содержать неуправляемый материал (или его отфильтровать препроцессором).

Неуправляемый файл заголовка интерфейса С++ (CppInterface.h):

#pragma once

#include <string>

// Sets the interface function decoration as export or import
#ifdef CSHARPWRAPPER_EXPORTS 
#define EXPORT_SPEC __declspec( dllexport )
#else
#define EXPORT_SPEC __declspec( dllimport )
#endif

// Unmanaged interface functions must use all unmanaged types
EXPORT_SPEC std::string GetDisplayString(const char * pName, int iValue);

Затем вы можете создать внутренний заголовочный файл, который можно включить в файлы управляемой библиотеки. Это добавит операторы using namespace и может включать вспомогательные функции, которые вам нужны.

Управляемый файл заголовка интерфейса С++ (CsharpInterface.h):

#pragma once

#include <string>

// .Net System Namespaces
using namespace System;
using namespace System::Runtime::InteropServices;

// C# Projects
using namespace CsharpProject;


//////////////////////////////////////////////////
// String Conversion Functions

inline
String ^ ToManagedString(const char * pString) {
 return Marshal::PtrToStringAnsi(IntPtr((char *) pString));
}

inline
const std::string ToStdString(String ^ strString) {
 IntPtr ptrString = IntPtr::Zero;
 std::string strStdString;
 try {
  ptrString = Marshal::StringToHGlobalAnsi(strString);
  strStdString = (char *) ptrString.ToPointer();
 }
 finally {
  if (ptrString != IntPtr::Zero) {
   Marshal::FreeHGlobal(ptrString);
  }
 }
 return strStdString;
}

Затем вы просто напишите свой код интерфейса, который делает обертку.

Управляемый исходный файл интерфейса С++ (CppInterface.cpp):

#include "CppInterface.h"
#include "CsharpInterface.h"

std::string GetDisplayString(const char * pName, int iValue) {
 CsharpClass ^ oCsharpObject = gcnew CsharpClass();

 oCsharpObject->Name = ToManagedString(pName);
 oCsharpObject->Value = iValue;

 return ToStdString(oCsharpObject->GetDisplayString());
}

Затем просто включите неуправляемый заголовок в неуправляемый проект, скажите компоновщику использовать сгенерированный .lib файл при связывании и убедитесь, что DLL файлы .Net и обертки находятся в той же папке, что и неуправляемое приложение.

#include <stdlib.h>

// Include the wrapper header
#include "CppInterface.h"

void main() {
 // Call the unmanaged wrapper function
 std::string strDisplayString = GetDisplayString("Test", 123);

 // Do something with it
 printf("%s\n", strDisplayString.c_str());
}

Ответ 2

Создайте новый проект С++/CLI в visual studio и добавьте ссылку на вашу С# dll. Предположим, что у нас есть С# dll, называемый DotNetLib.dll с этим классом в:

namespace DotNetLib
{
    public class Calc
    {
        public int Add(int a, int b)
        {
            return a + b;
        }
    }
}

Теперь добавьте класс CLR С++ в проект С++/CLI:

// TestCPlusPlus.h

#pragma once

using namespace System;
using namespace DotNetLib;

namespace TestCPlusPlus {

    public ref class ManagedCPlusPlus
    {
    public:
        int Add(int a, int b)
        {
            Calc^ c = gcnew Calc();
            int result = c->Add(a, b);
            return result;
        }
    };
}

Это вызовет С# из С++.

Теперь при необходимости вы можете добавить собственный С++-класс в свой проект С++/CLI, который может разговаривать с классом CLR С++:

// Native.h
#pragma once

class Native
{
public:
    Native(void);
    int Add(int a, int b);
    ~Native(void);
};

и

// Native.cpp
#include "StdAfx.h"
#include "Native.h"
#include "TestCPlusPlus.h"

Native::Native(void)
{
}

Native::~Native(void)
{
}

int Native::Add(int a, int b)
{
    TestCPlusPlus::ManagedCPlusPlus^ c = gcnew TestCPlusPlus::ManagedCPlusPlus();
    return c->Add(a, b);
}

Вы должны иметь возможность вызвать класс Native из любой другой родной библиотеки С++, как обычно.

Обратите внимание также, что Managed С++ отличается от С++/CLI и превосходит его. Википедия объясняет это лучше всего:

http://en.wikipedia.org/wiki/C%2B%2B/CLI