Comment appeler une DLL .NET à partir d'un processus Win32?

Question

Quelles sont les options pour utiliser une DLL .NET à partir d'un processus Win32? Je dois utiliser essentiellement une DLL C # à partir d'un processus Win32.

J'ai actuellement une solution possible qui nécessite l'ajout de la DLL C # au GAC (à l'aide de RegAsm.exe), puis l'appel de la DLL C # via des appels encapsulés dans COM. Cependant cette solution est assez lourde. Il faut que la DLL .NET soit ajoutée au GAC sur tous les machines supposées exécuter ce processus Win32.

Serait-il possible de le faire sans avoir à appeler RegAsm avant de pouvoir utiliser la DLL C #?

Answer 1

Vous pouvez utiliser COM sans inscription avec des composants COM .NET - voir ici .

Une autre option consiste à utiliser C ++ / CLI en tant que pont. Les utilisateurs sont généralement familiarisés avec son utilisation pour encapsuler des API non gérées afin de les exposer au code managé, mais cela fonctionne réellement dans les deux sens - il est possible de compiler avec / clr , tout en produisant un .dll assembly avec des exportations simples et non gérées, qui peuvent être appelées à partir d'un code non géré, comme d'habitude. Voici un exemple très simple qui expose System :: String :: ToUpper de cette façon:

// compile with cl.exe /clr /LD wrapper.cpp ole32.lib

#include <windows.h>

__declspec(dllexport)
wchar_t* ToUpper(const wchar_t* wcs)
{
    System::String^ s = gcnew System::String(wcs);
    array<wchar_t>^ chars = s->ToUpper()->ToCharArray();

    size_t size = chars->Length * 2;
    wchar_t* dst = (wchar_t*)CoTaskMemAlloc(size + 2);
    pin_ptr<wchar_t> src = &chars[0];
    memcpy(dst, src, size);
    dst[chars->Length] = 0;
    return dst;
}

Ceci produira wrapper.dll - assemblage hybride géré / non géré - et une bibliothèque d'exportation wrapper.lib . Ce dernier peut être utilisé dans une application native pure comme suit:

// compile with cl.exe test.cpp ole32.lib wrapper.lib
// note, no /clr

#include <stdio.h>
#include <windows.h>

wchar_t* ToUpper(const wchar_t* wcs);

int main()
{
    wchar_t* s = ToUpper(L"foo");  
    wprintf(L"%s", s);
    CoTaskMemFree(s);
}

En pratique, il charge le runtime CLR dans le processus appelant (sauf si il y est déjà chargé) et envoie du code natif au code géré de manière transparente: toute la magie est réalisée par le compilateur C ++ / CLI.

Answer 2

Il y a deux options.

Tout d'abord, vous pouvez utiliser Inscription COM libre interop . / p>

Deuxièmement, vous pouvez utiliser les API d'hébergement CLR directement à hébergez le CLR et chargez l'assembly. Cela fonctionne sans COM.