Как мне вызвать C ++ / CLI из C #?

Вы смотрели C ++ / CLI?

Приведу очень короткий пример. Вот исходный файл из проекта Visual C ++ - ›CLR -› Class Library. Он в основном получает имя пользователя Windows и возвращает его.

Обратите внимание, что для того, чтобы это скомпилировать, вы должны войти в настройки проекта и пометить Дополнительные зависимости как Наследовать от родителя, потому что мы используем эти библиотеки Windows (kernel32.lib, user32.lib, ..)

// CSCPP.h

#pragma once

#include "windows.h"

using namespace System;

namespace CSCPP {

    public ref class Class1
    {
        // TODO: Add your methods for this class here.
    public:
        String^ GetText(){
            WCHAR acUserName[100];
            DWORD nUserName = sizeof(acUserName);
            if (GetUserName(acUserName, &nUserName)) {
                String^ name = gcnew String(acUserName);
                return String::Format("Hello {0} !", name);
            }else{
                return gcnew String("Error!");
            }
        }
    };
}

Теперь создан новый проект C # и добавлена ​​ссылка на наш первый проект библиотеки классов C ++ / CLI. А затем вызовите метод экземпляра.

namespace CSTester
{
    class Program
    {
        static void Main(string[] args)
        {
            CSCPP.Class1 instance = new CSCPP.Class1();
            Console.WriteLine(instance.GetText());
        }
    }
}

На моей машине это дало следующий результат:

Привет m3rlinez!

C ++ / CLI - это, по сути, управляемое расширение стандарта C ++. Это позволяет вам использовать классы и типы данных CLR в вашем проекте C ++ / CLI, а также предоставлять их управляемому языку. Вы можете создать управляемую оболочку для своей старой библиотеки C ++, используя это. Есть несколько странных синтаксисов, таких как String^ для определения ссылочного типа для CLR String. Я нахожу Быстрый C ++ / CLI - Изучите C ++ / CLI менее чем за 10 минут, чтобы быть здесь полезным.

Есть как минимум три способа вызвать неуправляемый код из управляемого в одном процессе:

1. C ++ / CLI
2. Вызов платформы
3. Оберните свой C ++ в COM-объект

На работе для этого используем C ++ / CLI, вроде работает.

Я бы создал стандартную (не управляемую / управляемую) библиотеку динамических ссылок как , описанную здесь, а затем используйте атрибут DllImport (вызов платформы) в коде C # для доступа к экспортированным функциям.

Ключевой момент из этой статьи:

Обратите внимание на модификатор __declspec (dllexport) в объявлениях методов в этом коде. Эти модификаторы позволяют экспортировать метод библиотекой DLL, чтобы его могли использовать другие приложения. Для получения дополнительной информации см. Dllexport, dllimport.

Это более легкая альтернатива реальной оболочке COM-взаимодействия, позволяющая избежать таких проблем, как регистрация и т. Д. (DLL можно просто поместить в каталог приложения).

Другой альтернативой является It Just Works (IJW). Вероятно, это лучший выбор, если вы управляли кодом C ++ и вам нужно получить к нему доступ из других языков .NET. Но это вариант только в том случае, если вы можете / счастливы преобразовать свой неуправляемый C ++ в управляемый C ++.

Я бы держался подальше от P / Invoke, поскольку он довольно медленный по сравнению с IJW (It Just Works). Последний позволяет легко переплетать управляемый и неуправляемый C ++. Все, что вам нужно сделать, это создать управляемую сборку C ++, написать управляемый класс, видимый из C #, и вызвать из него неуправляемый код.

Эээ ... Хорошо. У меня создалось впечатление, что вызовы P / Invoke были медленнее, чего не было изначально. Однако, обладая явным контролем над маршалингом, вы можете улучшить работу своей версии C ++ / CLI во многих случаях.

Вот статья Microsoft об обоих механизмах:

http://msdn.microsoft.com/en-us/library/ms235282.aspx

Преимущества IJW

• Нет необходимости писать объявления атрибутов DLLImport для неуправляемых API-интерфейсов, используемых программой. Просто включите файл заголовка и свяжите его с библиотекой импорта.
• Механизм IJW немного быстрее (например, заглушкам IJW не нужно проверять необходимость закрепления или копирования элементов данных, потому что это явно делается разработчиком).
• Это ясно показывает проблемы с производительностью. В данном случае это тот факт, что вы переводите из строки Unicode в строку ANSI и что у вас есть сопутствующее выделение и освобождение памяти. В этом случае разработчик, пишущий код с использованием IJW, поймет, что вызов _putws и использование PtrToStringChars будет лучше для производительности.
• Если вы вызываете множество неуправляемых API-интерфейсов с использованием одних и тех же данных, их однократный маршалинг и передача маршалированной копии намного эффективнее, чем повторный маршалинг каждый раз.

Есть и эстетические преимущества:

• Код C # выглядит как код C # без каких-либо странностей взаимодействия.

• Вам не нужно определять атрибут DLLImport, вам не нужно определять какие-либо структуры данных (также с определенными атрибутами p / invoke), которые могут выглядеть следующим образом:

  [StructLayout (LayoutKind.Sequential, CharSet = CharSet.Ansi)] общедоступная структура DevMode {[MarshalAs (UnmanagedType.ByValTStr, SizeConst = 32)] общедоступная строка dmDeviceName; }

• Вам не нужно преобразовывать все примитивные типы параметров в их аналоги .NET (есть таблица на эта страница, на которой показано, как управляемые типы сопоставляются с неуправляемыми типами).
• Вы начинаете работать с C ++ / CLI, изучать который действительно интересно и отточенный. Он прошел долгий путь со времен VS 2003 и теперь является полнофункциональным языком .NET. Документация Microsoft по этому поводу довольно хороша, как и вся информация по IJW.
• Взаимодействие с C ++ в C ++ / CLI кажется очень естественным, в отличие от C #. Это полностью субъективно, но я бы предпочел маршалинг строк на C ++, который выполняет Marshal.PtrToString(ptr).
• Если вы открываете API, вы, вероятно, захотите обернуть все вещи P / Invoke на другом уровне, чтобы вам не приходилось иметь дело с уродством P / Invoke. Таким образом, у вас есть накладные расходы на всю сортировку и слой C # вокруг него. В C ++ / CLI маршаллинг и абстракция взаимодействия находятся в одном месте, и вы можете выбрать, какой уровень маршалинга вам нужен.

IMHO, если вы вызываете нечетную функцию в Windows SDK, используйте P / Invoke. Если вы представляете умеренно сложный C ++ API управляемому миру, определенно C ++ / CLI.