¿Cómo puedo especificar una ruta [DllImport] en tiempo de ejecución?

De hecho, obtuve una DLL de C ++ (en funcionamiento) que quiero importar a mi proyecto C # para llamar a sus funciones.

Funciona cuando especifico la ruta completa a la DLL, así:

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

El problema es que será un proyecto instalable, por lo que la carpeta del usuario no será la misma (por ejemplo, Pierre, Paul, Jack, Mum, Dad, ...) dependiendo de la computadora / sesión donde se ejecute.

Entonces me gustaría que mi código sea un poco más genérico, como este:

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

El gran problema es que "DllImport" desea un parámetro de "cadena constante" para el directorio de la DLL.

Entonces mi pregunta es: ¿Qué podría hacerse en este caso?

Contrariamente a las sugerencias de algunas de las otras respuestas, el uso del DllImportatributo sigue siendo el enfoque correcto.

Sinceramente, no entiendo por qué no puedes hacer lo mismo que todos los demás en el mundo y especificar una ruta relativa a tu DLL. Sí, la ruta en la que se instalará su aplicación difiere en las computadoras de diferentes personas, pero esa es básicamente una regla universal cuando se trata de la implementación. El DllImportmecanismo está diseñado con esto en mente.

De hecho, ni siquiera DllImporteso lo maneja. Son las reglas de carga de DLL de Win32 nativas las que gobiernan las cosas, independientemente de si está utilizando los prácticos contenedores administrados (el encargado de invocación P / Invoke solo llama LoadLibrary). Estas reglas se enumeran con gran detalle aquí , pero las importantes se extraen aquí:

Antes de que el sistema busque una DLL, verifica lo siguiente:

• Si una DLL con el mismo nombre de módulo ya está cargada en la memoria, el sistema usa la DLL cargada, sin importar en qué directorio se encuentre. El sistema no busca la DLL.
• Si la DLL está en la lista de DLL conocidas para la versión de Windows en la que se ejecuta la aplicación, el sistema usa su copia de la DLL conocida (y las DLL dependientes de la DLL conocida, si las hay). El sistema no busca la DLL.

---

Si SafeDllSearchModeestá habilitado (el valor predeterminado), el orden de búsqueda es el siguiente:

1. El directorio desde el que se cargó la aplicación.
2. El directorio del sistema. Use la GetSystemDirectoryfunción para obtener la ruta de este directorio.
3. El directorio del sistema de 16 bits. No hay ninguna función que obtenga la ruta de este directorio, pero se busca.
4. El directorio de Windows. Use la GetWindowsDirectoryfunción para obtener la ruta de este directorio.
5. El directorio actual.
6. Los directorios que se enumeran en la PATHvariable de entorno. Tenga en cuenta que esto no incluye la ruta por aplicación especificada por la clave de registro de rutas de aplicaciones. La clave de Rutas de aplicación no se usa al calcular la ruta de búsqueda de DLL.

Entonces, a menos que esté nombrando su DLL de la misma manera que una DLL del sistema (lo que obviamente no debería hacer, nunca, bajo ninguna circunstancia), el orden de búsqueda predeterminado comenzará a buscar en el directorio desde el que se cargó su aplicación. Si coloca la DLL allí durante la instalación, se encontrará. Todos los problemas complicados desaparecen si solo usa rutas relativas.

Solo escribe:

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

Pero si eso no funciona por alguna razón, y necesita forzar a la aplicación a buscar en la DLL un directorio diferente, puede modificar la ruta de búsqueda predeterminada utilizando la SetDllDirectoryfunción .
Tenga en cuenta que, según la documentación:

Después de llamar SetDllDirectory, la ruta de búsqueda estándar de DLL es:

1. El directorio desde el que se cargó la aplicación.
2. El directorio especificado por el lpPathNameparámetro.
3. El directorio del sistema. Use la GetSystemDirectoryfunción para obtener la ruta de este directorio.
4. El directorio del sistema de 16 bits. No hay ninguna función que obtenga la ruta de este directorio, pero se busca.
5. El directorio de Windows. Use la GetWindowsDirectoryfunción para obtener la ruta de este directorio.
6. Los directorios que se enumeran en la PATHvariable de entorno.

Por lo tanto, siempre que llame a esta función antes de llamar a la función importada de la DLL por primera vez, puede modificar la ruta de búsqueda predeterminada utilizada para ubicar las DLL. El beneficio, por supuesto, es que puede pasar un valor dinámico a esta función que se calcula en tiempo de ejecución. Eso no es posible con el DllImportatributo, por lo que aún usará una ruta relativa (solo el nombre de la DLL) allí, y dependerá del nuevo orden de búsqueda para encontrarlo.

Tendrás que P / Invocar esta función. La declaración se ve así:

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

Incluso mejor que la sugerencia de uso de Ran GetProcAddress, simplemente llame LoadLibraryantes de cualquier llamada a las DllImportfunciones (con solo un nombre de archivo sin ruta) y usarán el módulo cargado automáticamente.

He usado este método para elegir en tiempo de ejecución si cargar una DLL nativa de 32 o 64 bits sin tener que modificar un montón de funciones P / Invoke-d. Pegue el código de carga en un constructor estático para el tipo que tiene las funciones importadas y todo funcionará bien.

Si necesita un archivo .dll que no está en la ruta o en la ubicación de la aplicación, entonces no creo que pueda hacer eso, porque DllImportes un atributo, y los atributos son solo metadatos que se establecen en tipos, miembros y otros elementos del lenguaje

Una alternativa que puede ayudarlo a lograr lo que creo que está intentando es usar el nativo a LoadLibrarytravés de P / Invoke, para cargar un .dll de la ruta que necesita, y luego usarlo GetProcAddresspara obtener una referencia de la función que necesita de ese .dll. Luego, utilícelos para crear un delegado que pueda invocar.

Para que sea más fácil de usar, puede configurar este delegado en un campo en su clase, de modo que usarlo parezca llamar a un método miembro.

EDITAR

Aquí hay un fragmento de código que funciona y muestra lo que quise decir.

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

Nota: No me molesté en usarlo FreeLibrary, por lo que este código no está completo. En una aplicación real, debe tener cuidado al liberar los módulos cargados para evitar una pérdida de memoria.

Siempre que conozca el directorio donde se pueden encontrar sus bibliotecas de C ++ en tiempo de ejecución, esto debería ser simple. Puedo ver claramente que este es el caso en su código. Su myDll.dllestaría presente en el interior myLibFolderdel directorio dentro de la carpeta temporal del usuario actual.

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

Ahora puede continuar usando la instrucción DllImport usando una cadena constante como se muestra a continuación:

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

Justo en tiempo de ejecución antes de llamar a la DLLFunctionfunción (presente en la biblioteca de C ++) agregue esta línea de código en el código C #:

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

Esto simplemente le indica al CLR que busque las bibliotecas C ++ no administradas en la ruta del directorio que obtuvo en el tiempo de ejecución de su programa. Directory.SetCurrentDirectoryLa llamada establece el directorio de trabajo actual de la aplicación en el directorio especificado. Si su myDLL.dllestá presente en la ruta representada por la assemblyProbeDirectoryruta, entonces se cargará y la función deseada se llamará a través de p / invoke.

establecer la ruta dll en el archivo de configuración

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

antes de llamar al dll en tu aplicación, haz lo siguiente

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

luego llame al dll y puede usar como a continuación

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

DllImport funcionará bien sin la ruta completa especificada siempre que la dll esté ubicada en algún lugar de la ruta del sistema. Es posible que pueda agregar temporalmente la carpeta del usuario a la ruta.

Si todo falla, simplemente coloque la DLL en la windows\system32carpeta. El compilador lo encontrará. Especifique la DLL desde la cual cargar: DllImport("user32.dll"...configure EntryPoint = "my_unmanaged_function"para importar la función no administrada que desee a su aplicación 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);    
   }
}

Fuente e incluso más DllImportejemplos: http://msdn.microsoft.com/en-us/library/aa288468(v=vs.71).aspx