Как указать путь [DllImport] во время выполнения?

Question

Фактически, я получил C++ (рабочую) DLL, которую я хочу импортировать в свой проект C#, чтобы вызвать его функции.

Это делает работу, когда я указать полный путь к DLL, например:

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

Проблема заключается в том, что он собирается быть устанавливаемым проектом, поэтому папка пользователя не будет таким же (например: pierre, paul, jack, mum, dad, ...) в зависимости от компьютера/сеанса, на котором он будет запущен.

Так что я хочу, чтобы мой код, чтобы быть немного более общий характер, например:

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

Большая сделка является то, что «DllImport» желание параметра «Уст строка» для каталога библиотеки DLL.

Так что мой вопрос: Что можно сделать в этом случае?

Answer 1

Вопреки предложениям некоторых других ответов, использование атрибута DllImport по-прежнему является правильным.

Я честно не понимаю, почему вы не можете сделать так же, как все остальные в мире, и указать родственник путь к вашей DLL. Да, путь, в котором ваше приложение будет установлено, отличается на компьютерах разных людей, но это в основном универсальное правило, когда дело доходит до развертывания. Механизм DllImport разработан с учетом этого.

Фактически, это даже не DllImport, который обрабатывает его. Это правила загрузки загружаемых файлов Win32 DLL, которые управляют вещами, независимо от того, используете ли вы удобные управляемые обертки (маршаллер P/Invoke просто вызывает LoadLibrary). Эти правила перечислены в деталях here, но важные из них взяты здесь:

перед системой поиска для DLL, он проверяет следующее:

• Если DLL с тем же имя модуля уже загружено в память, система использует загруженную DLL, независимо от того, в какой директории она находится. Система не ищет DLL.
• Если DLL находится в списке известных DLL для версии Windows, на которой работает приложение, система использует свою копию известной DLL (и известных DLL-зависимых библиотек DLL, если таковые имеются). Система не ищет DLL.

---

Если SafeDllSearchMode включена (по умолчанию), порядок поиска выглядит следующим образом:

1. каталог, из которого загружается приложение.
2. Системный каталог. Используйте функцию GetSystemDirectory, чтобы получить путь к этому каталогу.
3. 16-разрядный системный каталог. Нет функции, которая получает путь к этому каталогу, но выполняется поиск.
4. Каталог Windows. Используйте функцию GetWindowsDirectory, чтобы получить путь к этому каталогу.
5. Текущий каталог.
6. Каталоги, перечисленные в переменной окружения PATH. Обратите внимание, что это не включает путь для каждого приложения, указанный в разделе реестра приложений. Ключ App Paths не используется при вычислении пути поиска DLL.

Так что, если вы не именовании DLL то же самое, как системный DLL (который вы, очевидно, не следует делать, никогда, ни при каких обстоятельствах), порядок поиска по умолчанию будет начать поиск в каталоге из которого была загружена ваша заявка. Если вы разместите DLL там во время установки, он будет найден. Все сложные проблемы уходят, если вы просто используете относительные пути.

Просто написать:

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

Но если не работу по какой-либо причине, и вам необходимо, чтобы заставить приложение искать в другом каталоге для DLL, вы можете изменить поиск по умолчанию с использованием SetDllDirectory function.
Обратите внимание, что, согласно документации:

После вызова SetDllDirectory, стандартный поиск DLL путь:

1. каталог, из которого загружается приложение.
2. Адрес, заданный параметром lpPathName.
3. Системный каталог. Используйте функцию GetSystemDirectory, чтобы получить путь к этому каталогу.
4. 16-разрядный системный каталог. Нет функции, которая получает путь к этому каталогу, но выполняется поиск.
5. Каталог Windows. Используйте функцию GetWindowsDirectory, чтобы получить путь к этому каталогу.
6. Каталоги, перечисленные в переменной окружения PATH.

Так до тех пор, как вы называете эту функцию перед вызовом функции импортируемой из DLL в первый раз, вы можете изменить путь поиска, используемый по умолчанию для поиска библиотек DLL. Выгода, конечно, состоит в том, что вы можете передать значение динамическое значение этой функции, которая вычисляется во время выполнения. Это невозможно с атрибутом DllImport, поэтому вы по-прежнему будете использовать относительный путь (только имя DLL) и полагаться на новый порядок поиска, чтобы найти его для вас.

Вам нужно будет P/вызвать эту функцию. Декларация выглядит так:

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

Answer 2

DllImport будет работать нормально, если не указан полный путь до тех пор, пока dll находится где-то на пути к системе. Возможно, вы сможете временно добавить папку пользователя в этот путь.

Answer 3

Если вам нужен DLL-файл, который не находится на пути или в местоположении приложения, то я не думаю, что вы можете сделать именно это, потому что DllImport - это атрибут, а атрибуты - это только метаданные, которые установлены на типов, членов и других элементов языка.

альтернатива, которая может помочь вам сделать то, что я думаю, что вы пытаетесь, чтобы использовать родной LoadLibrary через P/Invoke для того, чтобы загрузить DLL-файл с пути вам нужно, а затем использовать GetProcAddress, чтобы получить ссылку на нужную вам функцию .dll. Затем используйте их для создания делегата, который вы можете вызвать.

Чтобы упростить его использование, вы можете установить этот делегат в поле своего класса, чтобы его использование выглядело как вызов метода-члена.

EDIT

Вот фрагмент кода, который работает, и показывает, что я имел в виду.

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

Примечание: Я не стал использовать FreeLibrary, так что этот код не является полным. В реальном приложении вы должны позаботиться о выпуске загруженных модулей, чтобы избежать утечки памяти.

Answer 4

Если все не удается, просто поместите DLL в папку windows\system32. Компилятор найдет его. Укажите DLL для загрузки из с: DllImport("user32.dll"..., установите EntryPoint = "my_unmanaged_function" импортировать нужную неуправляемую функцию к вашему 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);  
    } 
} 

Источника и даже больше DllImport примеров: http://msdn.microsoft.com/en-us/library/aa288468(v=vs.71).aspx

Answer 5

Даже лучше, чем предложение Ран использования GetProcAddress, просто вызовите LoadLibrary перед любыми вызовами функций DllImport (только с именем файла без пути), и они автоматически загружают загруженный модуль.

Я использовал этот метод для выбора во время выполнения, нужно ли загружать 32-разрядную или 64-разрядную родную DLL без необходимости изменять кучу функций P/Invoke-d. Прикрепите код загрузки в статическом конструкторе для типа, который имеет импортированные функции, и все будет работать нормально.

Answer 6

Пока вы знаете каталог, в котором ваши библиотеки C++ могут быть найдены во время выполнения, это должно быть простым. Я ясно вижу, что это имеет место в вашем коде. Ваш myDll.dll будет присутствовать внутри каталога myLibFolder во временной папке текущего пользователя.

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

Теперь вы можете продолжать использовать оператор DllImport, используя константную строку, как показано ниже:

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

Только во время выполнения перед вызовом DLLFunction функции (присутствует в C++ библиотеки) добавить строку код в C# код:

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

Это просто инструктирует CLR искать неуправляемые C++ библиотек на пути к каталогу, который вы получили во время выполнения вашей программы. Directory.SetCurrentDirectory вызывает задание текущего рабочего каталога приложения в указанный каталог. Если ваш myDLL.dll присутствует на пути, представленном путем assemblyProbeDirectory, тогда он будет загружен, и желаемая функция будет вызвана через p/invoke.