Bagaimana cara menentukan jalur [DllImport] saat runtime?

Bahkan, saya mendapat DLL C ++ (berfungsi) yang ingin saya impor ke proyek C # untuk memanggil fungsinya.

Itu berfungsi ketika saya menentukan path lengkap ke DLL, seperti ini:

string str = "C:\\Users\\userName\\AppData\\Local\\myLibFolder\\myDLL.dll";
[DllImport(str, CallingConvention = CallingConvention.Cdecl)]
public static extern int DLLFunction(int Number1, int Number2);

Masalahnya adalah bahwa itu akan menjadi proyek yang dapat diinstal, sehingga folder pengguna tidak akan sama (mis: pierre, paul, jack, ibu, ayah, ...) tergantung komputer / sesi di mana ia akan dijalankan.

Jadi saya ingin kode saya menjadi sedikit lebih umum, seperti ini:

/* 
goes right to the temp folder of the user 
    "C:\\Users\\userName\\AppData\\Local\\temp"
then go to parent folder
    "C:\\Users\\userName\\AppData\\Local"
and finally go to the DLL's folder
    "C:\\Users\\userName\\AppData\\Local\\temp\\myLibFolder"
*/

string str = Path.GetTempPath() + "..\\myLibFolder\\myDLL.dll"; 
[DllImport(str, CallingConvention = CallingConvention.Cdecl)]
public static extern int DLLFunction(int Number1, int Number2);

Masalahnya adalah "DllImport" menginginkan parameter "const string" untuk direktori DLL.

Jadi pertanyaan saya adalah :: Apa yang bisa dilakukan dalam kasus ini?

Bertentangan dengan saran dari beberapa jawaban lain, penggunaan DllImportatribut masih merupakan pendekatan yang benar.

Jujur saya tidak mengerti mengapa Anda tidak bisa melakukan seperti orang lain di dunia dan menentukan jalur relatif ke DLL Anda. Ya, jalur di mana aplikasi Anda akan diinstal berbeda pada komputer orang yang berbeda, tapi itu pada dasarnya aturan universal ketika datang ke penyebaran. The DllImportMekanisme dirancang dengan pikiran ini.

Bahkan, itu bahkan tidak DllImportmenanganinya. Ini adalah aturan pemuatan asli Win32 DLL yang mengatur berbagai hal, terlepas dari apakah Anda menggunakan pembungkus yang mudah ditangani (marshaller P / Invoke hanya menelepon LoadLibrary). Aturan-aturan itu disebutkan dengan sangat rinci di sini , tetapi yang penting dikutip di sini:

Sebelum sistem mencari DLL, ia memeriksa yang berikut:

• Jika DLL dengan nama modul yang sama sudah dimuat dalam memori, sistem menggunakan DLL yang dimuat, tidak peduli di mana direktori itu berada. Sistem tidak mencari DLL.
• Jika DLL ada di daftar DLL yang dikenal untuk versi Windows di mana aplikasi berjalan, sistem menggunakan salinan DLL yang dikenal (dan DLL dependen DLL yang diketahui, jika ada). Sistem tidak mencari DLL.

---

Jika SafeDllSearchModediaktifkan (default), urutan pencarian adalah sebagai berikut:

1. Direktori tempat aplikasi dimuat.
2. Direktori sistem. Gunakan GetSystemDirectoryfungsi untuk mendapatkan jalur direktori ini.
3. Direktori sistem 16-bit. Tidak ada fungsi yang mendapatkan jalur direktori ini, tetapi sedang dicari.
4. Direktori Windows. Gunakan GetWindowsDirectoryfungsi untuk mendapatkan jalur direktori ini.
5. Direktori saat ini.
6. Direktori yang tercantum dalam PATHvariabel lingkungan. Perhatikan bahwa ini tidak termasuk jalur per-aplikasi yang ditentukan oleh kunci registri App Paths. Kunci App Paths tidak digunakan saat menghitung jalur pencarian DLL.

Jadi, kecuali jika Anda menamai DLL Anda dengan hal yang sama dengan DLL sistem (yang seharusnya tidak Anda lakukan, dalam keadaan apa pun), urutan pencarian default akan mulai mencari di direktori tempat aplikasi Anda dimuat. Jika Anda menempatkan DLL di sana selama instalasi, itu akan ditemukan. Semua masalah rumit hilang jika Anda hanya menggunakan jalur relatif.

Tulis saja:

[DllImport("MyAppDll.dll")] // relative path; just give the DLL's name
static extern bool MyGreatFunction(int myFirstParam, int mySecondParam);

Tetapi jika itu tidak berhasil karena alasan apa pun, dan Anda perlu memaksa aplikasi untuk mencari di direktori lain untuk DLL, Anda dapat memodifikasi jalur pencarian default menggunakan SetDllDirectoryfungsi .
Perhatikan bahwa, sesuai dokumentasi:

Setelah menelepon SetDllDirectory, jalur pencarian DLL standar adalah:

1. Direktori tempat aplikasi dimuat.
2. Direktori ditentukan oleh lpPathNameparameter.
3. Direktori sistem. Gunakan GetSystemDirectoryfungsi untuk mendapatkan jalur direktori ini.
4. Direktori sistem 16-bit. Tidak ada fungsi yang mendapatkan jalur direktori ini, tetapi sedang dicari.
5. Direktori Windows. Gunakan GetWindowsDirectoryfungsi untuk mendapatkan jalur direktori ini.
6. Direktori yang tercantum dalam PATHvariabel lingkungan.

Jadi, selama Anda memanggil fungsi ini sebelum Anda memanggil fungsi yang diimpor dari DLL untuk pertama kalinya, Anda dapat memodifikasi jalur pencarian default yang digunakan untuk menemukan DLL. Manfaatnya, tentu saja, adalah Anda dapat memberikan nilai dinamis ke fungsi ini yang dihitung pada saat dijalankan. Itu tidak mungkin dengan DllImportatribut, jadi Anda masih akan menggunakan jalur relatif (hanya nama DLL) di sana, dan bergantung pada urutan pencarian baru untuk menemukannya untuk Anda.

Anda harus P / Aktifkan fungsi ini. Deklarasi terlihat seperti ini:

[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
static extern bool SetDllDirectory(string lpPathName);

Bahkan lebih baik daripada saran Ran untuk menggunakan GetProcAddress, cukup buat panggilan LoadLibrarysebelum panggilan ke DllImportfungsi (hanya dengan nama file tanpa jalur) dan mereka akan menggunakan modul yang dimuat secara otomatis.

Saya telah menggunakan metode ini untuk memilih pada saat runtime apakah akan memuat DLL asli 32-bit atau 64-bit tanpa harus memodifikasi banyak fungsi P / Invoke-d. Masukkan kode pemuatan ke konstruktor statis untuk tipe yang memiliki fungsi yang diimpor dan semuanya akan berfungsi dengan baik.

Jika Anda memerlukan file .dll yang tidak ada di jalur atau di lokasi aplikasi, maka saya tidak berpikir Anda bisa melakukan itu, karena DllImportmerupakan atribut, dan atribut hanya metadata yang ditetapkan pada tipe, anggota dan lainnya elemen bahasa.

Alternatif yang dapat membantu Anda mencapai apa yang saya pikir Anda coba, adalah menggunakan asli LoadLibrarymelalui P / Invoke, untuk memuat .dll dari jalur yang Anda butuhkan, dan kemudian gunakan GetProcAddressuntuk mendapatkan referensi ke fungsi yang Anda butuhkan. dari itu. Kemudian gunakan ini untuk membuat delegasi yang dapat Anda panggil.

Untuk membuatnya lebih mudah digunakan, Anda dapat mengatur delegasi ini ke bidang di kelas Anda, sehingga menggunakannya tampak seperti memanggil metode anggota.

EDIT

Berikut ini cuplikan kode yang berfungsi, dan menunjukkan apa yang saya maksud.

class Program
{
    static void Main(string[] args)
    {
        var a = new MyClass();
        var result = a.ShowMessage();
    }
}

class FunctionLoader
{
    [DllImport("Kernel32.dll")]
    private static extern IntPtr LoadLibrary(string path);

    [DllImport("Kernel32.dll")]
    private static extern IntPtr GetProcAddress(IntPtr hModule, string procName);

    public static Delegate LoadFunction<T>(string dllPath, string functionName)
    {
        var hModule = LoadLibrary(dllPath);
        var functionAddress = GetProcAddress(hModule, functionName);
        return Marshal.GetDelegateForFunctionPointer(functionAddress, typeof (T));
    }
}

public class MyClass
{
    static MyClass()
    {
        // Load functions and set them up as delegates
        // This is just an example - you could load the .dll from any path,
        // and you could even determine the file location at runtime.
        MessageBox = (MessageBoxDelegate) 
            FunctionLoader.LoadFunction<MessageBoxDelegate>(
                @"c:\windows\system32\user32.dll", "MessageBoxA");
    }

    private delegate int MessageBoxDelegate(
        IntPtr hwnd, string title, string message, int buttons); 

    /// <summary>
    /// This is the dynamic P/Invoke alternative
    /// </summary>
    static private MessageBoxDelegate MessageBox;

    /// <summary>
    /// Example for a method that uses the "dynamic P/Invoke"
    /// </summary>
    public int ShowMessage()
    {
        // 3 means "yes/no/cancel" buttons, just to show that it works...
        return MessageBox(IntPtr.Zero, "Hello world", "Loaded dynamically", 3);
    }
}

Catatan: Saya tidak repot menggunakan FreeLibrary, jadi kode ini tidak lengkap. Dalam aplikasi nyata, Anda harus berhati-hati untuk melepaskan modul yang dimuat untuk menghindari kebocoran memori.

Selama Anda tahu direktori tempat pustaka C ++ Anda dapat ditemukan pada saat run time, ini harus sederhana. Saya dapat dengan jelas melihat bahwa ini adalah kasus dalam kode Anda. Anda myDll.dllakan berada di dalam myLibFolderdirektori di dalam folder sementara pengguna saat ini.

string str = Path.GetTempPath() + "..\\myLibFolder\\myDLL.dll"; 

Sekarang Anda dapat terus menggunakan pernyataan DllImport menggunakan string const seperti yang ditunjukkan di bawah ini:

[DllImport("myDLL.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int DLLFunction(int Number1, int Number2);

Tepat pada saat dijalankan sebelum Anda memanggil DLLFunctionfungsi (ada di perpustakaan C ++) tambahkan baris kode ini dalam kode C #:

string assemblyProbeDirectory = Path.GetTempPath() + "..\\myLibFolder\\myDLL.dll"; 
Directory.SetCurrentDirectory(assemblyProbeDirectory);

Ini hanya menginstruksikan CLR untuk mencari pustaka C ++ yang tidak dikelola di jalur direktori yang Anda peroleh saat menjalankan program Anda. Directory.SetCurrentDirectorypanggilan mengatur direktori kerja aplikasi saat ini ke direktori yang ditentukan. Jika Anda myDLL.dllhadir di path yang diwakili oleh assemblyProbeDirectorypath maka akan dimuat dan fungsi yang diinginkan akan dipanggil melalui p / invoke.

atur jalur dll dalam file konfigurasi

<add key="dllPath" value="C:\Users\UserName\YourApp\myLibFolder\myDLL.dll" />

sebelum memanggil dll di aplikasi Anda, lakukan hal berikut

string dllPath= ConfigurationManager.AppSettings["dllPath"];    
   string appDirectory = Path.GetDirectoryName(dllPath);
   Directory.SetCurrentDirectory(appDirectory);

lalu panggil dll dan Anda bisa gunakan seperti di bawah ini

 [DllImport("myDLL.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int DLLFunction(int Number1, int Number2);

DllImport akan bekerja dengan baik tanpa jalur lengkap yang ditentukan selama dll terletak di suatu tempat di jalur sistem. Anda mungkin dapat menambahkan folder pengguna untuk sementara waktu.

Jika semuanya gagal, cukup letakkan DLL di windows\system32folder. Kompiler akan menemukannya. Tentukan DLL untuk memuat dari dengan:, DllImport("user32.dll"...setel EntryPoint = "my_unmanaged_function"untuk mengimpor fungsi yang tidak dikelola yang Anda inginkan ke aplikasi C #:

 using System;
using System.Runtime.InteropServices;

class Example
{
   // Use DllImport to import the Win32 MessageBox function.

   [DllImport ("user32.dll", CharSet = CharSet.Auto)]
   public static extern int MessageBox 
      (IntPtr hWnd, String text, String caption, uint type);

   static void Main()
   {
      // Call the MessageBox function using platform invoke.
      MessageBox (new IntPtr(0), "Hello, World!", "Hello Dialog", 0);    
   }
}

Sumber dan bahkan lebih banyak DllImportcontoh: http://msdn.microsoft.com/en-us/library/aa288468(v=vs.71).aspx