С использованием класса, определенного в dll C++ в коде C#

Невозможно напрямую использовать класс C++ в коде C#. Вы можете использовать PInvoke косвенным образом для доступа к вашему типу.

Базовый шаблон состоит в том, что для каждой функции-члена в классе Foo создайте связанную функцию, не являющуюся членом, которая вызывает функцию-член.

class Foo {
public:
  int Bar();
};
extern "C" Foo* Foo_Create() { return new Foo(); }
extern "C" int Foo_Bar(Foo* pFoo) { return pFoo->Bar(); }
extern "C" void Foo_Delete(Foo* pFoo) { delete pFoo; }

Теперь нужно включить эти методы в ваш код C#.

[DllImport("Foo.dll")]
public static extern IntPtr Foo_Create();

[DllImport("Foo.dll")]
public static extern int Foo_Bar(IntPtr value);

[DllImport("Foo.dll")]
public static extern void Foo_Delete(IntPtr value);

Обратной стороной является неудобный IntPtr для передачи, но довольно просто создать класс-оболочку C# вокруг этого указателя, чтобы создать более удобную модель.

Даже если у вас нет этого кода, вы можете создать другую DLL, которая обертывает исходную DLL и предоставляет небольшой уровень PInvoke.

Возможно, вам потребуется написать промежуточную DLL (возможно, на C++), которая сделает это за вас и предоставит нужный вам интерфейс. Ваша DLL будет отвечать за загрузку сторонней DLL, создание экземпляра этого объекта C++ и предоставление его функций-членов по мере необходимости через любой разрабатываемый вами API. Затем вы должны использовать P / Invoke, чтобы получить доступ к своему API и аккуратно манипулировать объектом.

Примечание. Для API вашей DLL постарайтесь ограничить типы данных примитивами (long, int, char * и т. д.), Чтобы предотвратить проблемы с границами модуля.

Я согласен с JaredPar. Создание экземпляров неуправляемых классов в управляемом коде должно быть невозможно.

Другое дело - если бы вы могли перекомпилировать DLL в управляемом C++ или сделать из нее COM-компонент, это было бы намного проще /

Здесь - это пример вызова метода класса C++ из VB - для C# вам нужно только переписать пример программы на шаге 4.

Я сделал это, создав тонкую управляемую оболочку C++ вокруг моей неуправляемой библиотеки DLL C++. Управляемая оболочка содержит классы-посредники, которые охватывают неуправляемый код, открывая интерфейс, необходимый для приложения .NET. Это немного двойная работа, но она позволяет довольно плавно работать в нормальных условиях. В некоторых случаях (например, в ASP.NET) все становится сложнее с зависимостями, но вы, вероятно, не столкнетесь с этим.

Marshal C++ Class и используйте PInvoke

Код C++, ClassName.h

class __declspec(dllexport) CClassName
{
 public:
    CClassName();
    ~CClassName();
    void function();

};

Код C++, ClassName.cpp

CClassName::CClassName()
{
}

CClassName::~CClassName()
{
}

void CClassName::function()
{
    std::cout << "Bla bla bla" << std::endl;

}

Код C++, файл ClassNameCaller.h для вызывающей функции

#include "ClassName.h"      

#ifdef __cplusplus
extern "C" {
#endif

extern __declspec(dllexport) CClassName* CreateClassName();

extern __declspec(dllexport) void DisposeClassName(CClassName* a_pObject);

extern __declspec(dllexport) void function(CClassName* a_pObject);


#ifdef __cplusplus
}
#endif

Код C++, файл ClassNameCaller.cpp для вызывающей функции

#include "ClassNameCaller.h"


CClassName* CreateClassName()
{
    return new CClassName();
}

void DisposeClassName(CClassName* a_pObject)
{
    if (a_pObject!= NULL)
    {
        delete a_pObject;
        a_pObject= NULL;
    }
}

void function(CClassName* a_pObject)
{
    if (a_pObject!= NULL)
    {
        a_pObject->function();
    }
}

Код C#

[DllImport("ClassNameDll.dll")]
static public extern IntPtr CreateClassName();

[DllImport("ClassNameDll.dll")]
static public extern void DisposeClassName(IntPtr pClassNameObject);

[DllImport("ClassNameDll.dll")]
static public extern void CallFunction(IntPtr pClassNameObject);

//use the functions
IntPtr pClassName = CreateClassName();

CallFunction(pClassName);

DisposeClassName(pClassName);

pClassName = IntPtr.Zero;