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

Incluso mejor que la sugerencia de Ran de usar GetProcAddress, simplemente haga la llamada a LoadLibrary antes de cualquier llamada a las funciones DllImport (con solo un nombre de archivo sin una ruta) y usarán el módulo cargado automáticamente.

He utilizado este método para elegir en tiempo de ejecución si cargar un DLL nativo de 32 bits 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 funciona 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 precisamente eso, porque DllImport es un atributo, y los atributos son solo metadatos que se establece en tipos, miembros y otros elementos del lenguaje.

Una alternativa que puede ayudarle a lograr lo que creo que está tratando, es utilizar el nativo LoadLibrary a través de P/Invoke, con el fin de cargar a .dll de la ruta que necesita, y luego use GetProcAddress para obtener una referencia a la función de la que necesita que .DLL. A continuación, utilícelos para crear un delegado que pueda invocar.

Para que sea más fácil de usar, puede establecer 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 usar FreeLibrary, por lo que este código no está completo. En una aplicación real, debe tener cuidado de liberar los módulos cargados para evitar una memoria fuga.

Mientras 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.dll estaría presente dentro del directorio myLibFolder 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 const 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 función DLLFunction (presente en la biblioteca de C++) agregue esta línea de código en C# código:

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

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

DllImport funcionará bien sin la ruta completa especificada siempre y cuando 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 el DLL en la carpeta windows\system32. El compilador lo encontrará. Especifique la DLL desde la que cargar con: DllImport("user32.dll"..., establezca EntryPoint = "my_unmanaged_function" para importar la función no administrada deseada a su aplicación de 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 y aún más DllImport ejemplos: http://msdn.microsoft.com/en-us/library/aa288468 (v=vs.71). aspx