Как создать оболочку C ++ \ Cli для неуправляемых C DLL

Если Java может вызывать ваш код C через jna, тогда не должно быть проблем с С# через PInvoke. В то время как C++ interop (с использованием C++/Cli) является одним из типов PInvoke (Implicit PInvoke), использование DllImport является явным PInvoke.

Неявный PInvoke полезен, когда вам не нужно указывать, как будут параметризованы параметры функции, или любую другую информацию, которая может быть указана при явном вызове DllImportAttribute, но вам понадобится добавить дополнительную C++/CLI Dll.

В обоих случаях вам приходится иметь дело с собственными типами данных маршала для управляемых, это неизбежно и болезненно.

в С#, структура может быть объявлена как:

[StructLayout(LayoutKind.Sequential)]
    public struct myStruct {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        double prefix[] intersects;

        public int length;

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
        public double[] array;
    }

Но для этой функции DLLImport не может справиться с этим случаем, потому что С# не может удалить память для неуправляемого указателя, возвращаемого функцией, вы можете создать еще одну функцию переноса в C, чтобы она использовала параметр out для возврата результата, в этом случае код С#:

[DllImport("...")]
    public static extern void doSomething([In, Out] myStruct[] results,  myStruct[] input,  int len);

Или вы можете использовать C++/CLI interop, так как он может обрабатывать как собственные, так и управляющие типы, поэтому вызывающая последовательность:

1. Код С# вызывает эту функцию C++/CLI с управляемыми типами данных:

   ManagedmyStruct [] doSomething (ManagedmyStruct [] input, double a)

2. В функции C++/CLI domSomething она вызывает функцию native, этапы:

   ManagedmyStruct [] doSomething (ManagedmyStruct [] input, double a) {

     //convert the ManagedmyStruct[] input to native type myStruct* input
     myStruct ret* =  doSomething(input, a);
     //convert ret to managed type ManagedmyStruct[] rets
     return rets;
   

   }

Там действительно очень мало различий между оберткой C и C++. Вам необходимо создать библиотеку классов C++/CLI. Затем вы записываете функции в управляемый класс C++ ref, который переносит собственный код.

Например, предположим, что DLL экспортирует эту функцию:

int sqr(int x)

Затем в вашей библиотеке классов вы включите заголовочный файл:

#include <mynativelibrary.h>

Вам также необходимо предоставить библиотеку импорта в компоновщик.

Затем вы можете открыть функцию. Самый простой способ - обернуть функции как статические методы класса ref. Например:

public ref class Class1
{
public:
    static int sqr(int x)
    {
        return ::sqr(x);
    }
};

Затем вы можете использовать эту сборку в своем коде С#, как и в любой другой сборке.

Я создал несколько проектов в VisualStudio 2012, которые обертывают старую MFC-библиотеку с управляемым кодом. Я сделал это так:

1. Создайте библиотеку классов как CLR.
2. Свяжите старый проект с этим новым проектом
3. Создайте обертки в новом проекте для функций и структур и вызовите старый код.
4. Используйте новый объект в коде С#.

Не забудьте создать Unittesting для управляемого кода C++. (Я всегда забываю... :))

Удачи.