Korzystanie z biblioteki dll 32-bitowej lub 64-bitowej w C# DllImport

Question

Oto sytuacja, używam biblioteki dll opartej na C w mojej aplikacji dot.NET. Istnieją 2 biblioteki dll, jeden to 32-bitowy o nazwie MyDll32.dll, a drugi to wersja 64-bitowa o nazwie MyDll64.dll.

Istnieje zmienna statyczna przechowująca nazwę pliku DLL: ciąg DLL_FILE_NAME.

i stosuje się go w następujący sposób:

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

Proste tak daleko.

Jak można sobie wyobrazić, oprogramowanie zostało skompilowane z włączonym "dowolnym procesorem".

Mam również następujący kod, aby określić, czy system powinien używać pliku 64-bitowego czy 32-bitowego.

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

Teraz powinien pojawić się problemy .. DLL_FILE_NAME jest określona w czasie kompilacji, a nie w czasie wykonywania więc prawo dll nie jest załadowany w zależności od kontekstu wykonania.

Jaki byłby właściwy sposób rozwiązania tego problemu? Nie chcę dwóch plików wykonawczych (jednego dla 32-bitowego, a drugiego dla 64-bitowego)? Jak mogę ustawić plik DLL_FILE_NAME przed, który jest używany w instrukcji DllImport?

Answer 1

Znalazłem najprostszy sposób, aby to zrobić, to zaimportować dwie metody o różnych nazwach i wywołać właściwą. DLL nie zostanie załadowany aż połączenie zostanie wykonane tak, to w porządku:

[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); 
} 

Oczywiście, jeśli masz wiele importu, to można się dość kłopotliwe w utrzymaniu ręcznie.

Answer 2

Jest statyczna zmienna przytrzymując nazwę pliku DLL

To nie jest zmienną statyczną. Jest stała, w czasie kompilacji. Nie można zmienić stałej czasu kompilacji w czasie wykonywania.

Jaki byłby właściwy sposób rozwiązania tego problemu?

Szczerze polecam tylko kierowanie na x86 i jednoczesne zapominanie wersji 64-bitowej oraz zezwalanie na uruchamianie aplikacji na WOW64, o ile aplikacja nie musi wyświetlać się jako x64.

Jeśli istnieje zapotrzebowanie na x64, można:

• Zmiany DLLe mieć taką samą nazwę, jak MyDll.dll, a przy instalacji/wdrożyć czasie umieścić właściwy w miejscu. (Jeśli system operacyjny to x64, zainstaluj 64-bitową wersję biblioteki DLL, w przeciwnym razie wersję x86).

• Posiadają dwie osobne wersje: jedną dla x86 i drugą dla x64.

Answer 3

To, co opisujesz, jest znane jako "montaż side-by-side" (dwie wersje tego samego zestawu, jeden 32, a drugi 64 bit) ...Myślę, że znajdziesz to pomocne:

• Using Side-by-Side assemblies to load the x64 or x32 version of a DLL
• http://blogs.msdn.com/b/gauravseth/archive/2006/03/07/545104.aspx
• http://www.thescarms.com/dotnet/Assembly.aspx

Here można znaleźć instruktażu dokładnie scenariusza (.NET owijania DLL C++/CLI DLL odwoływania się natywna biblioteka DLL).

POLECAMY:

Wystarczy zbudować go jako x86 i być z nim zrobić ... albo mieć 2 buduje (jeden i jedna x86 x64) ... jak powyższe techniki są dość skomplikowane ...

Answer 4

Użyłem jednym z podejść meantioned przez vcsjones:

„Zmień DLL mieć taką samą nazwę, jak MyDll.dll, a przy instalacji/wdrożyć czasie umieścić prawo jeden w miejscu . "

Takie podejście wymaga utrzymywania dwóch platform kompilacji chociaż zobaczyć ten link po więcej szczegółów: https://stackoverflow.com/a/6446638/38368

Answer 5

Oto kolejna alternatywa, która wymaga, aby obie DLL mają samą nazwę i są umieszczone w różnych folderach. Na przykład:

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

Sztuką jest ręcznie załadować DLL z LoadLibrary przed CLR robi. Zobaczy wtedy, że MyDll.dll jest już załadowany i używa go.

Można to łatwo zrobić w statycznym konstruktorze klasy nadrzędnej.

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 01/02/2017 Use Assembly.CodeBase tak, że działa nawet jeśli Shadow Copying jest włączony.

Answer 6

W tym przypadku, należy zrobić tak (zrobić 2 foldery, x64 i x86 + umieścić odpowiedni dll z nazwą samo w obu folderach):

using System; 
using System.Runtime.InteropServices; 
using System.Reflection; 
using System.IO; 

class Program { 
    static void Main(string[] args) { 
     var path = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location); 
     path = Path.Combine(path, IntPtr.Size == 8 ? "x64" : "x86"); 
     bool ok = SetDllDirectory(path); 
     if (!ok) throw new System.ComponentModel.Win32Exception(); 
    } 
    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)] 
    private static extern bool SetDllDirectory(string path); 
} 

Answer 7

alternatywne podejście może być

public static class Sample 
{ 
    public Sample() 
    { 

     string StartupDirEndingWithSlash = System.IO.Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName) + "\\"; 
     string ResolvedDomainTimeFileName = StartupDirEndingWithSlash + "ABCLib_Resolved.dll"; 
     if (!File.Exists(ResolvedDomainTimeFileName)) 
     { 
      if (Environment.Is64BitProcess) 
      { 
       if (File.Exists(StartupDirEndingWithSlash + "ABCLib_64.dll")) 
        File.Copy(StartupDirEndingWithSlash + "ABCLib_64.dll", ResolvedDomainTimeFileName); 
      } 
      else 
      { 
       if (File.Exists(StartupDirEndingWithSlash + "ABCLib_32.dll")) 
        File.Copy(StartupDirEndingWithSlash + "ABCLib_32.dll", ResolvedDomainTimeFileName); 
      } 
     } 
    } 

    [DllImport("ABCLib__Resolved.dll")] 
    private static extern bool SomeFunctionName(ref int FT); 
}