C# - äquivalent von DllMain in C (WinAPI)

Ich habe für die Interaktion mit einer legacy-Anwendung, wahrscheinlich in der gleichen situation wie Sie. Ich habe ein hacky Weg, um DllMain-Funktionalität in einer CLR-assembly. Zum Glück ist es nicht allzu schwer. Es erfordert eine zusätzliche DLL, aber ist es nicht erforderlich, dass Sie bereitstellen eine zusätzliche DLL, so können Sie sich immer noch "legen Sie eine DLL in das Verzeichnis und die app laden Sie" - Paradigma.

Erste, Sie eine einfache normale C++ - DLL, die wie folgt aussieht:

dllmain.cpp:

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "resource.h"
extern void LaunchDll(
  unsigned char *dll, size_t dllLength, 
  char const *className, char const *methodName);
static DWORD WINAPI launcher(void* h)
{
    HRSRC res = ::FindResourceA(static_cast<HMODULE>(h),
                   MAKEINTRESOURCEA(IDR_DLLENCLOSED), "DLL");
    if (res)
    {
        HGLOBAL dat = ::LoadResource(static_cast<HMODULE>(h), res);
        if (dat)
        {
            unsigned char *dll =
                static_cast<unsigned char*>(::LockResource(dat));
            if (dll)
            {
                size_t len = SizeofResource(static_cast<HMODULE>(h), res);
                LaunchDll(dll, len, "MyNamespace.MyClass", "DllMain");
            }
        }
    }
    return 0;
}
extern "C" BOOL APIENTRY DllMain(HMODULE h, DWORD reasonForCall, void* resv)
{
    if (reasonForCall == DLL_PROCESS_ATTACH)
    {
        CreateThread(0, 0, launcher, h, 0, 0);
    }
    return TRUE;
}

Hinweis: der thread-Erstellung. Dies ist zu halten, Windows glücklich, weil aufrufen von verwaltetem code in einer DLL-entrypoint ist ein no-no.

Nächste, die Sie haben zu erstellen, die LaunchDll Funktion den code, der oben Verweise. Das geht in einer separaten Datei, da wird Sie kompiliert und als einer verwalteten C++ - unit-code. Um dies zu tun, erstellen Sie zunächst die .cpp-Datei (ich nannte es LaunchDll.cpp). Dann mit der rechten Maustaste auf die Datei in Ihrem Projekt und in Konfiguration Eigenschaften-->C/C++-->Allgemeinen ändern Sie die Common Language RunTime-Unterstützung Eintrag zu Common Language RunTime-Unterstützung (/clr). Sie können keine Ausnahmen, minimal rebuild-Laufzeit überprüft und vermutlich einige andere Dinge, die ich vergaß, aber der compiler wird Ihnen sagen, über. Wenn der compiler beschwert sich, die Spur, welche Einstellungen Sie viel ändern, von der Standardeinstellung und ändern Sie Sie auf die LaunchDll.cpp Datei nur.

LaunchDll.cpp:

#using <mscorlib.dll>
//Load a managed DLL from a byte array and call a static method in the DLL.
//dll - the byte array containing the DLL
//dllLength - the length of 'dll'
//className - the name of the class with a static method to call.
//methodName - the static method to call. Must expect no parameters.
void LaunchDll(
    unsigned char *dll, size_t dllLength,
    char const *className, char const *methodName)
{
    //convert passed in parameter to managed values
    cli::array<unsigned char>^ mdll = gcnew cli::array<unsigned char>(dllLength);
    System::Runtime::InteropServices::Marshal::Copy(
        (System::IntPtr)dll, mdll, 0, mdll->Length);
    System::String^ cn =
        System::Runtime::InteropServices::Marshal::PtrToStringAnsi(
            (System::IntPtr)(char*)className);
    System::String^ mn =
        System::Runtime::InteropServices::Marshal::PtrToStringAnsi(
            (System::IntPtr)(char*)methodName);

    //used the converted parameters to load the DLL, find, and call the method.
    System::Reflection::Assembly^ a = System::Reflection::Assembly::Load(mdll);
    a->GetType(cn)->GetMethod(mn)->Invoke(nullptr, nullptr);
}

Nun die wirklich schwierige Teil. Sie haben wahrscheinlich bemerkt, das laden von Ressourcen in dllmain.cpp:launcher(). Was es tut ist rufen Sie einen zweiten DLL, die eingelegt worden ist, als Ressource in die DLL immer hier geschaffen. Um dies zu tun, erstellen Sie eine Ressource-Datei, indem Sie die
rechten Maustaste-->Hinzufügen-->Neues Element-->Visual C++-->Ressource-->Ressource-Datei (.rc) Sache. Dann müssen Sie, um sicherzustellen, dass es ist eine Zeile wie:

Ressource.rc:

IDR_DLLENCLOSED DLL "C:\\Path\\to\\Inner.dll"

in der Datei. (Tricky, huh?)

Das einzige, was noch zu tun ist, zu schaffen, die Inner.dll Montage. Aber, Sie bereits haben! Dies ist, was Sie versuchen zu starten mit Ihren legacy-app in den ersten Platz. Nur stellen Sie sicher, dass Sie eine MyNamespace.MyClass Klasse mit einem public void DllMain() Methode (natürlich können Sie diese Funktionen aufrufen, was Sie wollen, das sind nur die Werte hardcoded in dllmain.cpp:launcher (oben).

So, zum Schluss, den code oben eine vorhandene verwaltete DLL, fügt Sie in eine Ressource, die von einer nicht verwalteten DLL, die auf immer angebracht, um einen Prozess, lädt die verwaltete DLL aus den Ressourcen und eine Methode aufrufen.

Links als übung für den Leser besser ist, Fehler zu überprüfen, laden verschiedener DLLs, die für Debug und Release, etc. Modus, Aufruf von DllMain-Ersatz mit den gleichen Argumenten an die realen DllMain (die B. nur ist es für DLL_PROCESS_ATTACH), und hardcoding anderen Methoden der inneren DLL in den äußeren DLL als pass-through-Methoden.

InformationsquelleAutor mheyman

Obwohl C# nicht direkt-support-Modul-Initialisierung, die wir implementieren können, mit Reflexion und statische Konstruktoren. Um dies zu tun, können wir ein benutzerdefiniertes Attribut, und verwenden Sie es finden Klassen, die initialisiert werden müssen, die auf das Modul geladen wird:

public class InitOnLoadAttribute : Attribute {}

private void InitAssembly(Assembly assembly)
{
    foreach (var type in GetLoadOnInitTypes(assembly)){
        var prop = type.GetProperty("loaded", BindingFlags.Static | BindingFlags.NonPublic); //note that this only exists by convention
        if(prop != null){
            prop.GetValue(null, null); //causes the static ctor to be called if it hasn't already
        }
    }
 }

static IEnumerable<Type> GetLoadOnInitTypes(Assembly assembly)
{
    foreach (Type type in assembly.GetTypes())
    {
        if (type.GetCustomAttributes(typeof(InitOnLoadAttribute), true).Length > 0){
            yield return type;
        }
    }
}

public MyMainClass()
{
    //init newly loaded assemblies
    AppDomain.CurrentDomain.AssemblyLoad += (s, o) => InitAssembly(o.LoadedAssembly); 
    //and all the ones we currently have loaded
    foreach(var assembly in AppDomain.CurrentDomain.GetAssemblies()){
        InitAssembly(assembly);
    }
}

auf Klassen, die wir brauchen, um zu initialisieren wir sofort hinzufügen, dass code Ihrer statischen Konstruktor (die nur einmal ausgeführt wird, selbst wenn die Eigenschaft getter zugegriffen wird mehrfach) und fügen Sie das benutzerdefinierte Attribut, die wir Hinzugefügt, um zu bewirken, dass diese Funktionalität.

[InitOnLoad]
class foo
{
    private static bool loaded { get { return true; } }
    static foo() 
    {
        int i = 42;
    }
}

InformationsquelleAutor Yaur