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

Question

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

J'ai une solution possible en ce moment qui nécessite l'ajout de la DLL C# au GAC (en utilisant RegAsm.exe), puis en appelant la DLL C# via des appels enveloppés COM. Cependant, cette solution est assez lourde. Il nécessite que la DLL .NET soit ajoutée au GAC sur toutes 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 avec des composants .NET COM sans enregistrement - voir here.

Une autre option consiste à utiliser C++/CLI en tant que pont. Les gens sont habitués à l'utiliser pour encapsuler des API non gérées afin de les exposer au code managé, mais cela fonctionne dans les deux sens: il est possible de compiler avec /clr et de produire un assembly .dll avec des exports non gérés, qui peuvent être appelés à partir du code non managé comme d'habitude. Voici un exemple très simple qui expose System::String::ToUpper 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; 
} 

Cela produira wrapper.dll - assemblage géré/non géré hybride - et une bibliothèque d'exportation wrapper.lib. Ce dernier peut être utilisé dans une application pure native 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); 
} 

Dans la pratique, il se charge de l'exécution CLR dans le processus d'appel (à moins qu'il y a déjà chargé) et l'expédition à partir du code natif à code managé de façon transparente - tous les la magie est faite par le compilateur C++/CLI.

Answer 2

Il existe deux options. D'abord, vous pouvez utiliser Registration Free COM Interop. Deuxièmement, vous pouvez utiliser le CLR Hosting APIs pour héberger directement le CLR et charger l'ensemble. Cela fonctionne sans COM.