Çalışma zamanında [DllImport] yolunu nasıl belirleyebilirim?

Aslında, işlevleri çağırmak için C # projem içine almak istediğiniz bir C ++ (çalışma) DLL var.

Ben böyle DLL için tam yol belirttiğinizde çalışır:

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

Sorun, yüklenebilir bir proje olacağı için, kullanıcının klasörü çalıştırılacağı bilgisayara / oturuma bağlı olarak aynı olmayacaktır (örn: pierre, paul, jack, anne, baba, ...).

Bu yüzden kodumun biraz daha genel olmasını istiyorum, şöyle:

/* 
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);

Önemli olan "DllImport" DLL dizini için bir "const dize" parametresi arzu olmasıdır.

Yani sorum şu: Bu durumda ne yapılabilir?

Diğer cevapların bazılarının önerilerinin aksine, DllImportniteliği kullanmak hala doğru yaklaşımdır.

Dürüst olmak gerekirse neden dünyadaki herkes gibi yapamıyorsunuz ve DLL için göreceli bir yol belirtmiyorum . Evet, uygulamanızın yükleneceği yol farklı kişilerin bilgisayarlarında farklılık gösterir, ancak bu dağıtım konusunda temelde evrensel bir kuraldır. DllImportMekanizma Bu düşünceyle tasarlanmıştır.

Aslında, bunu bile DllImporthalledemez. Kullanışlı yönetilen sarmalayıcıları (P / Invoke marshaller sadece çağırır LoadLibrary) kullanıp kullanmadığınızdan bağımsız olarak işleri yöneten yerel Win32 DLL yükleme kurallarıdır . Bu kurallar burada ayrıntılı olarak numaralandırılmıştır , ancak önemli kurallar burada belirtilmiştir:

Sistem bir DLL dosyasını aramadan önce aşağıdakileri kontrol eder:

• Aynı modül adına sahip bir DLL zaten belleğe yüklenmişse, sistem hangi dizinde olursa olsun yüklü DLL'yi kullanır. Sistem DLL'yi aramaz.
• DLL, uygulamanın çalıştığı Windows sürümü için bilinen DLL listesindeyse, sistem bilinen DLL (ve varsa bilinen DLL bağımlı DLL) kopyasını kullanır. Sistem DLL'yi aramaz.

---

Eğer SafeDllSearchMode(varsayılan) etkinleştirildiğinde aşağıdaki gibi arama sırası:

1. Uygulamanın yüklendiği dizin.
2. Sistem dizini. GetSystemDirectoryBu dizinin yolunu almak için işlevi kullanın .
3. 16 bit sistem dizini. Bu dizinin yolunu alan bir işlev yoktur, ancak aranır.
4. Windows dizini. GetWindowsDirectoryBu dizinin yolunu almak için işlevi kullanın .
5. Geçerli dizin.
6. PATHOrtam değişkeninde listelenen dizinler . Bunun, Uygulama Yolları kayıt defteri anahtarı tarafından belirtilen uygulama başına yolu içermediğini unutmayın. Uygulama yolları anahtarı, DLL arama yolu hesaplanırken kullanılmaz.

Bu nedenle, DLL'nizi bir sistem DLL'si ile aynı şekilde adlandırmıyorsanız (ki hiçbir koşulda hiçbir zaman yapmamanız gerekir), varsayılan arama sırası uygulamanızın yüklendiği dizinde aramaya başlayacaktır. DLL dosyasını yükleme sırasında oraya yerleştirirseniz bulunur. Göreli yolları kullanırsanız, tüm karmaşık sorunlar ortadan kalkar.

Sadece yaz:

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

Ancak bu herhangi bir nedenle işe yaramazsa ve uygulamayı DLL için farklı bir dizine bakmaya zorlamanız gerekiyorsa, SetDllDirectoryişlevi kullanarak varsayılan arama yolunu değiştirebilirsiniz .
Belgelere göre:

Aramadan sonra SetDllDirectorystandart DLL arama yolu:

1. Uygulamanın yüklendiği dizin.
2. lpPathNameParametre tarafından belirtilen dizin .
3. Sistem dizini. GetSystemDirectoryBu dizinin yolunu almak için işlevi kullanın .
4. 16 bit sistem dizini. Bu dizinin yolunu alan bir işlev yoktur, ancak aranır.
5. Windows dizini. GetWindowsDirectoryBu dizinin yolunu almak için işlevi kullanın .
6. PATHOrtam değişkeninde listelenen dizinler .

DLL'den ilk kez içe aktarılan işlevi aramadan önce bu işlevi çağırdığınız sürece, DLL'leri bulmak için kullanılan varsayılan arama yolunu değiştirebilirsiniz. Avantajı, elbette, çalışma zamanında hesaplanan bu işleve dinamik bir değer iletebilmenizdir . Bu DllImportözellik ile mümkün değildir , bu yüzden orada göreceli bir yol (yalnızca DLL'in adı) kullanacak ve sizin için bulmak için yeni arama sırasına güveneceksiniz.

Bu işlevi P / Çağırmanız gerekir. Bildirge şöyle:

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

Daha da iyisi kullanmanın Ran'ın önerisi daha GetProcAddressbasitçe çağrısı yapmak LoadLibraryçağrılmadan önce DllImport(bir yola sahip olmayan tek bir dosya adıyla) fonksiyonları ve bunlar otomatik yüklenen modülünü kullanacağız.

Bir sürü P / Invoke-d işlevlerini değiştirmek zorunda kalmadan 32-bit veya 64-bit yerel DLL yüklemek isteyip istemediğinizi seçmek için bu yöntemi kullandım. Yükleme kodunu, içe aktarılan işlevlere sahip tür için statik bir yapıcıya yapıştırın ve hepsi iyi çalışır.

Yolda veya uygulamanın konumunda olmayan bir .dll dosyasına ihtiyacınız varsa, o zaman bunu yapabileceğinizi sanmıyorum, çünkü DllImportbir özniteliktir ve öznitelikler yalnızca türler, üyeler ve diğer dil öğeleri.

Denediğimi başarmanıza yardımcı olabilecek bir alternatif, LoadLibraryihtiyacınız olan yoldan bir .dll yüklemek için P / Invoke aracılığıyla yerel'i kullanmak ve daha sonra GetProcAddressihtiyacınız olan işleve referans almak için kullanmaktır . bu .dll'den. Ardından, çağırabileceğiniz bir temsilci oluşturmak için bunları kullanın.

Kullanımı daha kolay hale getirmek için, bu temsilciyi sınıfınızdaki bir alana ayarlayabilirsiniz, böylece kullanmak bir üye yöntemini çağırmak gibi görünür.

DÜZENLE

İşte çalışan ve ne demek istediğimi gösteren bir kod snippet'i.

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

Not: Ben kullanmak için uğraşmadı FreeLibrary, bu yüzden bu kod tam değil. Gerçek bir uygulamada, bellek sızıntısını önlemek için yüklü modülleri serbest bırakmaya dikkat etmelisiniz.

C ++ kitaplıklarınızın çalışma zamanında bulunabileceği dizini bildiğiniz sürece, bu basit olmalıdır. Kodunuzda durumun bu olduğunu açıkça görebiliyorum. Sizin myDll.dllMevcut içeride olurdu myLibFolderGeçerli kullanıcının geçici klasör içinde dizin.

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

Şimdi aşağıda gösterildiği gibi bir const dizesi kullanarak DllImport deyimini kullanmaya devam edebilirsiniz:

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

DLLFunction(C ++ kitaplığında bulunur) işlevi çağırmadan hemen önce çalışma zamanında bu kod satırını C # koduna ekleyin:

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

Bu, CLR'ye programınızın çalışma zamanında elde ettiğiniz dizin yolundaki yönetilmeyen C ++ kitaplıklarını aramasını bildirir. Directory.SetCurrentDirectorycall, uygulamanın geçerli çalışma dizinini belirtilen dizine ayarlar. Eğer senin myDLL.dlltarafından temsil yolda mevcut olduğu assemblyProbeDirectoryyolundaki o zaman yüklenir alacak ve istenen fonksiyon p / Invoke aracılığıyla adlı.

yapılandırma dosyasında dll yolunu ayarlama

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

uygulamasında dll çağırmadan önce aşağıdakileri yapın

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

sonra dll arayın ve aşağıdaki gibi kullanabilirsiniz

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

DllImport, dll sistem yolunda bir yerde bulunduğu sürece belirtilen tam yol olmadan iyi çalışır. Kullanıcının klasörünü yola geçici olarak ekleyebilirsiniz.

Hepsi başarısız olursa, DLL dosyasını windows\system32klasöre yerleştirin. Derleyici bulacaktır. Yüklenecek DLL dosyasını belirtin:, istediğiniz yönetilmeyen işlevi C # uygulamanıza aktarmak için DllImport("user32.dll"...ayarlayın EntryPoint = "my_unmanaged_function":

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

Kaynak ve hatta daha fazla DllImportörnek: http://msdn.microsoft.com/en-us/library/aa288468(v=vs.71).aspx