Using a 32bit or 64bit dll in C# DllImport

Question

Here is the situation, I'm using a C based dll in my dot.net application. There are 2 dlls, one is 32bit called MyDll32.dll and the other is a 64bit version called MyDll64.dll.

There is a static variable holding the DLL file name: string DLL_FILE_NAME.

and it is used in the following way:

[DllImport(DLL_FILE_NAME, CallingConvention=CallingConvention.Cdecl, EntryPoint=Func1")] private static extern int is_Func1(int var1, int var2); 

Simple so far.

As you can imagine, the software is compiled with "Any CPU" turned on.

I also have the following code to determine if the system should use the 64bit file or the 32bit file.

#if WIN64         public const string DLL_FILE_NAME = "MyDll64.dll"; #else         public const string DLL_FILE_NAME = "MyDll32.dll";         #endif 

By now you should see the problem.. DLL_FILE_NAME is defined in compilation time and not in execution time so the right dll isn't loaded according to the execution context.

What would be the correct way to deal with this issue? I do not want two execution files (one for 32bit and the other for 64bit)? How can I set DLL_FILE_NAME before it is used in the DllImport statement?

Answer 1

I've found the simplest way to do this is to import the two methods with different names, and calling the right one. The DLL won't be loaded until the call is made so it's fine:

[DllImport("MyDll32.dll", EntryPoint = "Func1", CallingConvention = CallingConvention.Cdecl)] private static extern int Func1_32(int var1, int var2);  [DllImport("MyDll64.dll", EntryPoint = "Func1", CallingConvention = CallingConvention.Cdecl)] private static extern int Func1_64(int var1, int var2);  public static int Func1(int var1, int var2) {     return IntPtr.Size == 8 /* 64bit */ ? Func1_64(var1, var2) : Func1_32(var1, var2); } 

Of course, if you have many imports, this can be become quite cumbersome to maintain manually.

Answer 2

Here is another alternative that requires that the two DLLs have the same name and are placed in different folders. For instance:

• win32/MyDll.dll
• win64/MyDll.dll

The trick is to manually load the DLL with LoadLibrary before the CLR does it. It will then see that a MyDll.dll is already loaded and use it.

This can be done easily in the static constructor of the parent class.

static class MyDll {     static MyDll()     {                     var myPath = new Uri(typeof(MyDll).Assembly.CodeBase).LocalPath;         var myFolder = Path.GetDirectoryName(myPath);          var is64 = IntPtr.Size == 8;         var subfolder = is64 ? "\\win64\\" : "\\win32\\";          LoadLibrary(myFolder + subfolder + "MyDll.dll");     }      [DllImport("kernel32.dll")]     private static extern IntPtr LoadLibrary(string dllToLoad);      [DllImport("MyDll.dll")]     public static extern int MyFunction(int var1, int var2); } 

EDIT 2017/02/01: Use Assembly.CodeBase so that it works even if Shadow Copying is enabled.